chore: bump version to 1.3.7

Major improvements in this release:
- Added comprehensive logging system with file and console output
- Implemented signal blocking context manager for safer Qt operations
- Added complete type hints throughout the codebase
- Fixed unsafe bar pool recycling with removed flag tracking
- Added system font fallbacks for cross-platform compatibility
- Improved error handling with proper exception logging
- Added configuration validation with automatic value clamping
- Added thread-safety documentation for input monitoring
- Removed magic numbers by moving constants to VisualSettings
- Fixed bar_color property to use @Property decorator

This release represents a significant code quality improvement with
production-ready error handling, logging, and cross-platform support.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Ian-bug

build.py

@@ -3,6 +3,16 @@
 import shutil
 import subprocess
 import sys
+import logging
+
+# Setup basic logging for build script
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
 from core.settings_manager import SettingsManager
 
 CONFIG_FILES = ['config.ini', 'config.cfg']
@@ -18,13 +28,13 @@ def clean_directories():
     dirs_to_clean = [OUTPUT_DIR, BUILD_DIR]
     for d in dirs_to_clean:
         if os.path.exists(d):
-            print(f"Cleaning {d}...")
+            logger.info(f"Cleaning {d}...")
             shutil.rmtree(d)
 
 def build(debug_mode):
     """Invokes PyInstaller to build the executable."""
-    print(f"Building {EXECUTABLE_NAME} (Debug Mode: {debug_mode})...")
-    
+    logger.info(f"Building {EXECUTABLE_NAME} (Debug Mode: {debug_mode})...")
+
     cmd = [
         'pyinstaller',
         '--onedir',
@@ -41,7 +51,7 @@ def build(debug_mode):
     # Note: We don't explicitly add --add-data here because we copy config manually after build.
     # If hidden imports are needed (e.g. pynput, PySide6), PyInstaller usually finds them.
     # If issues arise, we can add --hidden-import.
-    
+
     # Run PyInstaller
     subprocess.check_call(cmd)
 
@@ -56,42 +66,42 @@ def copy_config_to_dist():
         if os.path.exists(cfg):
             input_config = cfg
             shutil.copy2(input_config, target_dir)
-            print(f"Copied {input_config} to {target_dir}")
+            logger.info(f"Copied {input_config} to {target_dir}")
             copied = True
             break
-    
+
     if not copied:
-        print("Warning: No config file found to copy.")
+        logger.warning("No config file found to copy.")
 
 def create_zip(debug_mode):
     """Packages the dist folder into a zip file."""
     source_dir = os.path.join(OUTPUT_DIR, EXECUTABLE_NAME)
-    
+
     zip_name = EXECUTABLE_NAME
     if debug_mode:
         zip_name += "-debug"
-    
+
     # shutil.make_archive expects the base_name without extension
     # It creates base_name.zip
-    
-    print(f"\nPackaging into {zip_name}.zip...")
-    
+
+    logger.info(f"Packaging into {zip_name}.zip...")
+
     # format='zip': create a zip file
     # root_dir=OUTPUT_DIR: the root directory to archive
     # base_dir=EXECUTABLE_NAME: the directory inside root_dir to start archiving from
     # This prevents the zip from containing 'dist/...' structure, but rather just the executable folder
-    
+
     # We want the zip to contain the top-level folder 'RainingKeysPython'
     # So we archive 'dist' but only the 'RainingKeysPython' subdirectory
-    
+
     shutil.make_archive(zip_name, 'zip', root_dir=OUTPUT_DIR, base_dir=EXECUTABLE_NAME)
-    print(f"Zip created: {zip_name}.zip")
+    logger.info(f"Zip created: {zip_name}.zip")
 
 def update_config_debug_mode(debug_mode):
     """Updates config.ini to match the current build mode."""
     # We read the config to preserve other settings, but force debug_mode
     config = configparser.ConfigParser()
-    
+
     # Manually read to handle potential BOM (Byte Order Mark) issues
     read_success = False
     for cfg in CONFIG_FILES:
@@ -102,8 +112,8 @@ def update_config_debug_mode(debug_mode):
                 read_success = True
                 break
             except Exception as e:
-                print(f"Warning: Could not read {cfg}: {e}")
-    
+                logger.warning(f"Could not read {cfg}: {e}")
+
     # Ensure sections exist
     if not config.has_section('General'):
         if config.has_section('Debug'):
@@ -113,41 +123,41 @@ def update_config_debug_mode(debug_mode):
             config.add_section('General')
             config.set('General', 'debug_mode', str(debug_mode))
     else:
-         config.set('General', 'debug_mode', str(debug_mode))
-    
+        config.set('General', 'debug_mode', str(debug_mode))
+
     # Write back
     # We pick the first available config file to write to, usually config.ini
     target_cfg = CONFIG_FILES[0]
     with open(target_cfg, 'w', encoding='utf-8') as f:
         config.write(f)
 
 def run_build_cycle(debug_mode):
-    print(f"\n>>> Starting {'DEBUG' if debug_mode else 'RELEASE'} Build Cycle <<<")
-    
+    logger.info(f"\n>>> Starting {'DEBUG' if debug_mode else 'RELEASE'} Build Cycle <<<")
+
     # Reset config to defaults if building for Release
     if not debug_mode:
-        print("Resetting configuration to defaults for Release build...")
+        logger.info("Resetting configuration to defaults for Release build...")
         try:
             settings = SettingsManager()
             settings.reset_to_defaults()
-            print("Configuration reset successful.")
+            logger.info("Configuration reset successful.")
         except Exception as e:
-            print(f"Warning: Failed to reset configuration: {e}")
+            logger.warning(f"Failed to reset configuration: {e}")
 
     # Update config file so the built executable reads the correct mode at runtime
     # AND so that the copy_config_to_dist puts the correct config in the dist folder
     update_config_debug_mode(debug_mode)
-    
+
     # Build
     try:
         build(debug_mode)
     except subprocess.CalledProcessError as e:
-        print(f"Error during build: {e}")
+        logger.error(f"Error during build: {e}")
         sys.exit(1)
-        
+
     # Copy Config
     copy_config_to_dist()
-    
+
     # Zip
     create_zip(debug_mode)
 
@@ -157,25 +167,25 @@ def main():
 
     # 2. Check dependencies
     try:
-        subprocess.call(['pyinstaller', '--version'], stdout=subprocess.DEVNULL)
+        subprocess.call(['pyinstaller', '--version'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     except FileNotFoundError:
-         print("Error: 'pyinstaller' not found. Please install it via 'pip install pyinstaller'.")
-         sys.exit(1)
+        logger.error("'pyinstaller' not found. Please install it via 'pip install pyinstaller'.")
+        sys.exit(1)
 
     # 3. Release Build (Normal)
     run_build_cycle(debug_mode=False)
-    
+
     # 4. Debug Build
     # We clean build/ between runs to ensure clean state, but NOT dist/ (so we keep the zips)
     if os.path.exists(BUILD_DIR):
         shutil.rmtree(BUILD_DIR)
-        
+
     run_build_cycle(debug_mode=True)
 
-    print("\nAll builds complete!")
-    print(f"Artifacts located in project root:")
-    print(f" - {EXECUTABLE_NAME}.zip")
-    print(f" - {EXECUTABLE_NAME}-debug.zip")
+    logger.info("\nAll builds complete!")
+    logger.info(f"Artifacts located in project root:")
+    logger.info(f" - {EXECUTABLE_NAME}.zip")
+    logger.info(f" - {EXECUTABLE_NAME}-debug.zip")
 
 if __name__ == "__main__":
     main()

core/configuration.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass, field
-from typing import Dict, List
+from typing import Dict, List, Optional
 from PySide6.QtGui import QColor
+from .logging_config import get_logger
+
+logger = get_logger(__name__)
 
 @dataclass
 class VisualSettings:
@@ -10,20 +13,59 @@ class VisualSettings:
     bar_height: int = 20
     bar_color_str: str = "0,255,255,200"
     fall_direction: str = "up"
-    
+
+    # Display constants
+    LANE_START_X: int = 50
+    EXTRA_PADDING: int = 50
+    KEYVIEWER_OFFSET_Y_TOP: int = 50
+    KEYVIEWER_OFFSET_Y_BOTTOM: int = 50
+    FALLBACK_SCREEN_HEIGHT: int = 1080
+
     @property
     def bar_color(self) -> QColor:
+        """Parse and validate color string, returning QColor."""
         try:
-            r, g, b, a = map(int, self.bar_color_str.split(','))
+            parts = self.bar_color_str.split(',')
+            if len(parts) != 4:
+                raise ValueError("Color must have 4 components (R,G,B,A)")
+
+            r, g, b, a = map(int, parts)
+            # Validate ranges
+            if not all(0 <= x <= 255 for x in [r, g, b, a]):
+                raise ValueError("Color values must be between 0 and 255")
+
             return QColor(r, g, b, a)
-        except ValueError:
+        except (ValueError, AttributeError) as e:
+            logger.warning(f"Invalid color string '{self.bar_color_str}': {e}. Using default.")
             return QColor(0, 255, 255, 200)
 
 @dataclass
 class PositionSettings:
     x: int = 0
     y: int = 0
 
+    def validate(self) -> bool:
+        """Validate position values are within reasonable bounds.
+
+        Returns:
+            True if all values were valid, False if any were clamped.
+        """
+        MIN_POS = -10000
+        MAX_POS = 10000
+        valid = True
+
+        if not (MIN_POS <= self.x <= MAX_POS):
+            logger.warning(f"X position {self.x} out of range, clamping to [{MIN_POS}, {MAX_POS}]")
+            self.x = max(MIN_POS, min(MAX_POS, self.x))
+            valid = False
+
+        if not (MIN_POS <= self.y <= MAX_POS):
+            logger.warning(f"Y position {self.y} out of range, clamping to [{MIN_POS}, {MAX_POS}]")
+            self.y = max(MIN_POS, min(MAX_POS, self.y))
+            valid = False
+
+        return valid
+
 @dataclass
 class KeyViewerSettings:
     enabled: bool = True
@@ -35,6 +77,34 @@ class KeyViewerSettings:
     height: int = 60
     opacity: float = 0.2
 
+    def validate(self) -> bool:
+        """Validate KeyViewer settings.
+
+        Returns:
+            True if all values were valid, False if any were clamped/changed.
+        """
+        valid = True
+
+        # Validate height
+        if not (10 <= self.height <= 500):
+            logger.warning(f"KeyViewer height {self.height} out of range [10, 500], clamping")
+            self.height = max(10, min(500, self.height))
+            valid = False
+
+        # Validate opacity
+        if not (0.0 <= self.opacity <= 1.0):
+            logger.warning(f"KeyViewer opacity {self.opacity} out of range [0.0, 1.0], clamping")
+            self.opacity = max(0.0, min(1.0, self.opacity))
+            valid = False
+
+        # Validate panel_position
+        if self.panel_position not in ("above", "below"):
+            logger.warning(f"Invalid panel_position '{self.panel_position}', using 'below'")
+            self.panel_position = "below"
+            valid = False
+
+        return valid
+
 @dataclass
 class AppConfig:
     visual: VisualSettings = field(default_factory=VisualSettings)
@@ -48,13 +118,18 @@ class AppConfig:
     FADE_START_Y: int = 800
     FADE_RANGE: int = 200
     DEBUG_MODE: bool = False
-    VERSION: str = "1.3.5"
+    VERSION: str = "1.3.7"
 
     def __post_init__(self):
         if not self.lane_map:
             self.lane_map = {'d': 0, 'f': 1, 'j': 2, 'k': 3}
 
-    def set_lane_keys(self, keys: List[str]):
+    def set_lane_keys(self, keys: List[str]) -> None:
+        """Set lane key mapping.
+
+        Args:
+            keys: List of key strings to map to lanes (by index).
+        """
         new_map = {}
         for idx, key in enumerate(keys):
             new_map[key] = idx