refactor: replace global config with AppConfig dataclass and dependency injection

Author: Ian-bug

README.md

@@ -42,7 +42,7 @@ RainingKeys is a purely external overlay application that visualizes keyboard in
 ```text
 RainingKeysPython/
 ├── core/
-│   ├── config.py           # Default configuration constants
+│   ├── configuration.py    # Dataclasses for application configuration
 │   ├── gui.py              # Configuration Window GUI
 │   ├── input_mon.py        # Global input listener
 │   ├── overlay.py          # Main rendering loop and window logic

core/config.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+from typing import Dict, List
+from PySide6.QtGui import QColor
+
+@dataclass
+class VisualSettings:
+    scroll_speed: int = 800
+    lane_width: int = 70
+    bar_width: int = 70
+    bar_height: int = 20
+    bar_color_str: str = "0,255,255,200"
+    
+    @property
+    def bar_color(self) -> QColor:
+        try:
+            r, g, b, a = map(int, self.bar_color_str.split(','))
+            return QColor(r, g, b, a)
+        except ValueError:
+            return QColor(0, 255, 255, 200)
+
+@dataclass
+class PositionSettings:
+    x: int = 0
+    y: int = 0
+
+@dataclass
+class KeyViewerSettings:
+    enabled: bool = False
+    layout: str = "horizontal"
+    panel_position: str = "below"
+    panel_offset_x: int = 0
+    panel_offset_y: int = 0
+    show_counts: bool = True
+    height: int = 60
+    opacity: float = 0.2
+
+@dataclass
+class AppConfig:
+    visual: VisualSettings = field(default_factory=VisualSettings)
+    position: PositionSettings = field(default_factory=PositionSettings)
+    key_viewer: KeyViewerSettings = field(default_factory=KeyViewerSettings)
+    lane_map: Dict[str, int] = field(default_factory=dict)
+    
+    # Constants
+    MAX_BARS: int = 300
+    INPUT_LATENCY_OFFSET: float = 0.0
+    FADE_START_Y: int = 800
+    FADE_RANGE: int = 200
+    DEBUG_MODE: bool = False
+    VERSION: str = "1.2.0"
+    
+    # Derived properties could go here, but kept simple for now
+    
+    def set_lane_keys(self, keys: List[str]):
+        new_map = {}
+        for idx, key in enumerate(keys):
+            new_map[key] = idx
+        self.lane_map = new_map

core/configuration.py

@@ -2,13 +2,13 @@
 from PySide6.QtCore import Qt, Slot
 from PySide6.QtGui import QColor, QPalette
 from .settings_manager import SettingsManager
-from .config import Config
 
 class SettingsWindow(QWidget):
     def __init__(self, settings_manager: SettingsManager):
         super().__init__()
         self.settings = settings_manager
-        self.setWindowTitle(f"RainingKeys Config v{Config.VERSION}")
+        self.config = self.settings.app_config
+        self.setWindowTitle(f"RainingKeys Config v{self.config.VERSION}")
         self.resize(300, 350)
 
         # Recording State
@@ -27,13 +27,13 @@ def init_ui(self):
         self.spin_x = QSpinBox()
         self.spin_x.setRange(-10000, 10000)
         self.spin_x.setPrefix("X: ")
-        self.spin_x.setValue(self.settings.overlay_x)
+        self.spin_x.setValue(self.config.position.x)
         self.spin_x.valueChanged.connect(self.on_pos_changed)
 
         self.spin_y = QSpinBox()
         self.spin_y.setRange(-10000, 10000)
         self.spin_y.setPrefix("Y: ")
-        self.spin_y.setValue(self.settings.overlay_y)
+        self.spin_y.setValue(self.config.position.y)
         self.spin_y.valueChanged.connect(self.on_pos_changed)
 
         pos_layout.addWidget(self.spin_x)
@@ -45,23 +45,13 @@ def init_ui(self):
         vis_group = QGroupBox("Visual Settings")
         vis_layout = QVBoxLayout()
 
-        # Direction (REMOVED: Bound to Position)
-        # dir_layout = QHBoxLayout()
-        # dir_layout.addWidget(QLabel("Fall Direction:"))
-        # self.combo_dir = QComboBox()
-        # self.combo_dir.addItems(["down", "up"])
-        # self.combo_dir.setCurrentText(self.settings.fall_direction)
-        # self.combo_dir.currentTextChanged.connect(self.on_visual_changed)
-        # dir_layout.addWidget(self.combo_dir)
-        # vis_layout.addLayout(dir_layout)
-        
         # Speed
         speed_layout = QHBoxLayout()
         speed_layout.addWidget(QLabel("Scroll Speed (px/s):"))
         self.spin_speed = QSpinBox()
         self.spin_speed.setRange(100, 5000)
         self.spin_speed.setSingleStep(50)
-        self.spin_speed.setValue(self.settings.scroll_speed)
+        self.spin_speed.setValue(self.config.visual.scroll_speed)
         self.spin_speed.valueChanged.connect(self.on_visual_changed)
         speed_layout.addWidget(self.spin_speed)
         vis_layout.addLayout(speed_layout)
@@ -82,7 +72,7 @@ def init_ui(self):
         lane_group = QGroupBox("Lane Configuration")
         lane_layout = QVBoxLayout()
 
-        self.lbl_lane_status = QLabel("Current Keys: " + str(len(Config.LANE_MAP)))
+        self.lbl_lane_status = QLabel("Current Keys: " + str(len(self.config.lane_map)))
         self.lbl_lane_status.setWordWrap(True)
         lane_layout.addWidget(self.lbl_lane_status)
 
@@ -102,7 +92,7 @@ def init_ui(self):
         kv_layout = QVBoxLayout()
 
         self.chk_kv_enabled = QCheckBox("Enable KeyViewer")
-        self.chk_kv_enabled.setChecked(self.settings.kv_enabled)
+        self.chk_kv_enabled.setChecked(self.config.key_viewer.enabled)
         self.chk_kv_enabled.stateChanged.connect(self.on_kv_changed)
         kv_layout.addWidget(self.chk_kv_enabled)
 
@@ -111,15 +101,14 @@ def init_ui(self):
         kv_grid.addWidget(QLabel("Height:"))
         self.spin_kv_height = QSpinBox()
         self.spin_kv_height.setRange(10, 500)
-        self.spin_kv_height.setValue(self.settings.kv_height)
+        self.spin_kv_height.setValue(self.config.key_viewer.height)
         self.spin_kv_height.valueChanged.connect(self.on_kv_changed)
         kv_grid.addWidget(self.spin_kv_height)
 
         kv_grid.addWidget(QLabel("Pos:"))
         self.combo_kv_pos = QComboBox()
         self.combo_kv_pos.addItems(["below", "above"])
-        # Handle removed 'auto' gracefully if config still has it
-        current = self.settings.kv_position
+        current = self.config.key_viewer.panel_position
         if current not in ["below", "above"]:
              current = "below" 
         self.combo_kv_pos.setCurrentText(current)
@@ -132,13 +121,13 @@ def init_ui(self):
         off_layout.addWidget(QLabel("Offset X:"))
         self.spin_kv_off_x = QSpinBox()
         self.spin_kv_off_x.setRange(-1000, 1000)
-        self.spin_kv_off_x.setValue(self.settings.kv_offset_x)
+        self.spin_kv_off_x.setValue(self.config.key_viewer.panel_offset_x)
         self.spin_kv_off_x.valueChanged.connect(self.on_kv_changed)
         off_layout.addWidget(self.spin_kv_off_x)
         off_layout.addWidget(QLabel("Y:"))
         self.spin_kv_off_y = QSpinBox()
         self.spin_kv_off_y.setRange(-1000, 1000)
-        self.spin_kv_off_y.setValue(self.settings.kv_offset_y)
+        self.spin_kv_off_y.setValue(self.config.key_viewer.panel_offset_y)
         self.spin_kv_off_y.valueChanged.connect(self.on_kv_changed)
         off_layout.addWidget(self.spin_kv_off_y)
         kv_layout.addLayout(off_layout)
@@ -149,13 +138,13 @@ def init_ui(self):
         self.spin_kv_opacity = QSpinBox()
         self.spin_kv_opacity.setRange(0, 100)
         self.spin_kv_opacity.setSuffix("%")
-        self.spin_kv_opacity.setValue(int(self.settings.kv_opacity * 100))
+        self.spin_kv_opacity.setValue(int(self.config.key_viewer.opacity * 100))
         self.spin_kv_opacity.valueChanged.connect(self.on_kv_changed)
         trans_layout.addWidget(self.spin_kv_opacity)
         kv_layout.addLayout(trans_layout)
 
         self.chk_kv_counts = QCheckBox("Show Key Counts")
-        self.chk_kv_counts.setChecked(self.settings.kv_show_counts)
+        self.chk_kv_counts.setChecked(self.config.key_viewer.show_counts)
         self.chk_kv_counts.stateChanged.connect(self.on_kv_changed)
         kv_layout.addWidget(self.chk_kv_counts)
 
@@ -166,40 +155,39 @@ def init_ui(self):
         self.setLayout(layout)
 
     def on_pos_changed(self):
-        self.settings.set('Position', 'x', self.spin_x.value())
-        self.settings.set('Position', 'y', self.spin_y.value())
-        self.settings.save() 
+        self.config.position.x = self.spin_x.value()
+        self.config.position.y = self.spin_y.value()
+        self.settings.save()
 
     def choose_color(self):
-        current = self.settings.bar_color
+        current = self.config.visual.bar_color
         color = QColorDialog.getColor(current, self, "Select Bar Color", QColorDialog.ShowAlphaChannel)
         if color.isValid():
             rgba = f"{color.red()},{color.green()},{color.blue()},{color.alpha()}"
-            self.settings.set('Visual', 'bar_color', rgba)
+            self.config.visual.bar_color_str = rgba
             self.settings.save()
             self.update_color_btn_style()
 
     def update_color_btn_style(self):
-        c = self.settings.bar_color
+        c = self.config.visual.bar_color
         # Text color contrasting
         text_col = "black" if c.lightness() > 128 else "white"
         style = f"background-color: rgba({c.red()},{c.green()},{c.blue()},{c.alpha()}); color: {text_col};"
         self.btn_color.setStyleSheet(style)
         self.btn_color.setText(f"RGBA({c.red()},{c.green()},{c.blue()},{c.alpha()})") 
 
     def on_visual_changed(self):
-        # self.settings.set('Visual', 'fall_direction', self.combo_dir.currentText())
-        self.settings.set('Visual', 'scroll_speed', self.spin_speed.value())
+        self.config.visual.scroll_speed = self.spin_speed.value()
         self.settings.save()
 
     def on_kv_changed(self):
-        self.settings.set('keyviewer', 'enabled', self.chk_kv_enabled.isChecked())
-        self.settings.set('keyviewer', 'height', self.spin_kv_height.value())
-        self.settings.set('keyviewer', 'panel_position', self.combo_kv_pos.currentText())
-        self.settings.set('keyviewer', 'panel_offset_x', self.spin_kv_off_x.value())
-        self.settings.set('keyviewer', 'panel_offset_y', self.spin_kv_off_y.value())
-        self.settings.set('keyviewer', 'show_counts', self.chk_kv_counts.isChecked())
-        self.settings.set('keyviewer', 'opacity', self.spin_kv_opacity.value() / 100.0)
+        self.config.key_viewer.enabled = self.chk_kv_enabled.isChecked()
+        self.config.key_viewer.height = self.spin_kv_height.value()
+        self.config.key_viewer.panel_position = self.combo_kv_pos.currentText()
+        self.config.key_viewer.panel_offset_x = self.spin_kv_off_x.value()
+        self.config.key_viewer.panel_offset_y = self.spin_kv_off_y.value()
+        self.config.key_viewer.show_counts = self.chk_kv_counts.isChecked()
+        self.config.key_viewer.opacity = self.spin_kv_opacity.value() / 100.0
         self.settings.save()
 
     def toggle_recording(self):
@@ -218,10 +206,8 @@ def toggle_recording(self):
 
             if self.recorded_keys:
                 # Save
-                self.settings.save_lanes(self.recorded_keys)
+                self.settings.update_lanes(self.recorded_keys)
                 self.lbl_lane_status.setText(f"Saved {len(self.recorded_keys)} lane keys.")
-                
-                # Update overlay if needed? save_lanes emits settings_changed which overlay listens to.
             else:
                  self.lbl_lane_status.setText("No keys recorded. Canceled.")
 

core/gui.py

@@ -1,7 +1,7 @@
 import time
 from PySide6.QtCore import QObject, Signal, QThread
 from pynput import keyboard
-from .config import Config
+from .configuration import AppConfig
 
 class InputWorker(QObject):
     """
@@ -12,8 +12,9 @@ class InputWorker(QObject):
     key_released = Signal(int, float) # lane_index, timestamp
     raw_key_pressed = Signal(str)     # raw_key_string
 
-    def __init__(self):
+    def __init__(self, app_config: AppConfig):
         super().__init__()
+        self.config = app_config
         self.listener = None
         self.running = False
         self.active_keys = set() # Track pressed keys to filter autorepeats
@@ -50,10 +51,10 @@ def on_press(self, key):
 
         self.raw_key_pressed.emit(k_str)
 
-        if k_str in Config.LANE_MAP:
+        if k_str in self.config.lane_map:
             self.active_keys.add(k_str)
             timestamp = time.perf_counter()
-            lane_idx = Config.LANE_MAP[k_str]
+            lane_idx = self.config.lane_map[k_str]
             self.key_pressed.emit(lane_idx, timestamp)
 
     def on_release(self, key):
@@ -65,9 +66,9 @@ def on_release(self, key):
         if k_str in self.active_keys:
             self.active_keys.remove(k_str)
 
-        if k_str in Config.LANE_MAP:
+        if k_str in self.config.lane_map:
             timestamp = time.perf_counter()
-            lane_idx = Config.LANE_MAP[k_str]
+            lane_idx = self.config.lane_map[k_str]
             self.key_released.emit(lane_idx, timestamp)
 
 class InputMonitor(QThread):
@@ -78,9 +79,9 @@ class InputMonitor(QThread):
     key_released = Signal(int, float)
     raw_key_pressed = Signal(str)
 
-    def __init__(self):
+    def __init__(self, app_config: AppConfig):
         super().__init__()
-        self.worker = InputWorker()
+        self.worker = InputWorker(app_config)
         self.worker.key_pressed.connect(self.key_pressed.emit)
         self.worker.key_released.connect(self.key_released.emit)
         self.worker.raw_key_pressed.connect(self.raw_key_pressed.emit)