Multiple Fixes & New Mouse Filtering Feature

keyboard_chattering.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=Keyboard Chattering Fix service
+# Tell systemd to stop this service before going to sleep, and start it after waking up
+After=suspend.target
+After=hibernate.target
+After=hybrid-sleep.target
+
+[Service]
+# Wait 3 seconds before starting the script to give the USB bus and Wayland time to fully wake up
+ExecStartPre=/bin/sleep 3
+# Change ExecStart to the absolute path of the file, executing keyboard_chattering.sh
+ExecStart=<absolute/path/to/file/keyboard_chattering.sh>
+
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+WantedBy=suspend.target
+WantedBy=hibernate.target
+WantedBy=hybrid-sleep.target

keyboard_chattering.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# Change the line below to the absolute path of the folder.
+# You can append `--keys KEY_A,KEY_SPACE` at the very end to ONLY filter those specific keys.
+# (If using modern Linux/Python, you may need to run: sudo pip3 install -r requirements.txt --break-system-packages)
+
+cd </absolute/path/to/folder> && sudo python3 -m src.keyboard_main -k <KEYBOARD id> -t 30

mouse_chattering.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=Mouse Chattering service
+# Tell systemd to stop this service before going to sleep, and start it after waking up
+After=suspend.target
+After=hibernate.target
+After=hybrid-sleep.target
+
+[Service]
+# Wait 3 seconds before starting the script to give the USB bus and Wayland time to fully wake up
+ExecStartPre=/bin/sleep 3
+# Change ExecStart to the absolute path of the file, executing mouse_chattering.sh
+ExecStart=<absolute/path/to/file/mouse_chattering.sh>
+
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+WantedBy=suspend.target
+WantedBy=hibernate.target
+WantedBy=hybrid-sleep.target

mouse_chattering.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# Change the line below to the absolute path of the folder.
+# You can append `--buttons BTN_LEFT,BTN_SIDE` at the very end to ONLY filter those specific buttons.
+# (If using modern Linux/Python, you may need to run: sudo pip3 install -r requirements.txt --break-system-packages)
+
+cd </absolute/path/to/folder> && sudo python3 -m src.mouse_main -m <MOUSE id> -t 30

src/keyboard_config.py

@@ -0,0 +1,43 @@
+"""
+Constants for keyboard chattering filter configuration.
+
+PRECEDENCE RULES:
+1. Command Line (--keys): Highest priority. If provided, this file is ignored.
+2. This File (FILTERED_KEYS): Used if no command line argument is provided.
+3. Empty: If BOTH the command line and this list are empty, ALL keys will be filtered.
+"""
+
+# To filter specific keys, add them to this set. 
+# Example: FILTERED_KEYS = {"KEY_A", "KEY_SPACE", "KEY_ENTER"}
+# Leave it empty as set() to filter ALL keys by default.
+FILTERED_KEYS = set()
+
+
+# ==========================================
+# REFERENCE: COMMON KEY VALUES TO COPY/PASTE
+# ==========================================
+# Letters: 
+# KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J, 
+# KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T, 
+# KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z
+#
+# Numbers (Top Row): 
+# KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0, KEY_MINUS, KEY_EQUAL
+#
+# Numpad: 
+# KEY_KP0 to KEY_KP9, KEY_KPMINUS, KEY_KPPLUS, KEY_KPASTERISK, KEY_KPDOT, KEY_KPENTER
+#
+# Special/Control: 
+# KEY_SPACE, KEY_ENTER, KEY_BACKSPACE, KEY_TAB, KEY_ESC, KEY_CAPSLOCK
+# 
+# Modifiers: 
+# KEY_LEFTSHIFT, KEY_RIGHTSHIFT, KEY_LEFTCTRL, KEY_RIGHTCTRL, KEY_LEFTALT, KEY_RIGHTALT, KEY_LEFTMETA (Super/Windows)
+# 
+# Arrows & Navigation: 
+# KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT, KEY_HOME, KEY_END, KEY_PAGEUP, KEY_PAGEDOWN, KEY_INSERT, KEY_DELETE
+# 
+# Function Keys: 
+# KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11, KEY_F12
+#
+# Punctuation: 
+# KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_SEMICOLON, KEY_APOSTROPHE, KEY_GRAVE, KEY_BACKSLASH, KEY_COMMA, KEY_DOT, KEY_SLASH

src/keyboard_filtering.py

@@ -0,0 +1,86 @@
+import logging
+from collections import defaultdict
+from typing import DefaultDict, Dict, NoReturn, List
+import time
+import libevdev
+import sys
+
+def filter_chattering(evdev: libevdev.Device, threshold: int, keys_to_filter: List[libevdev.EventCode] = None) -> NoReturn:
+    # Delay to allow the Enter key (used to execute the terminal command) 
+    # to release natively before we grab the device. Prevents a "stuck" Enter key.
+    time.sleep(1) 
+
+    # Grab the physical device so only we see the events it emits
+    evdev.grab()
+
+    # Create a virtual uinput device to emit our cleaned events back to the OS
+    ui_dev = evdev.create_uinput_device()
+
+    logging.info("Listening to keyboard input events...")
+
+    if not keys_to_filter:
+        keys_to_filter = []
+
+    while True:
+        # Descriptor is blocking; waits until physical events are available
+        try:
+            for e in evdev.events():
+                if _from_keystroke(e, threshold, keys_to_filter):
+                    ui_dev.send_events([e, libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, 0)])
+        except OSError as err:
+            # Errno 19 means "No such device". This happens if the USB is suddenly unplugged.
+            if err.errno == 19:
+                logging.critical("Keyboard disconnected while listening. Exiting gracefully.")
+                sys.exit(0)
+            else:
+                raise err
+
+
+def _from_keystroke(event: libevdev.InputEvent, threshold: int, keys_to_filter: List[libevdev.EventCode]) -> bool:
+    global _last_key_code
+
+    # Ignore sync/misc events. libevdev uinput handles syncing natively.
+    if event.matches(libevdev.EV_SYN) or event.matches(libevdev.EV_MSC):
+        return False
+
+    # MODIFIER FIX: If the event isn't a key, or it's a "hold" event (event.value > 1), forward it immediately.
+    # This ensures held keys (like Shift or Ctrl) don't get interrupted by the chatter filter.
+    if not event.matches(libevdev.EV_KEY) or event.value > 1:
+        logging.debug(f'FORWARDING {event.code}')
+        return True
+
+    # TARGETED FILTERING: If the user provided specific keys to fix, and this isn't one of them, forward it.
+    if keys_to_filter and event.code not in keys_to_filter:
+        logging.debug(f'FORWARDING {event.code} (not in targeted filter list)')
+        return True
+
+    # Process standard Key Up (0) and Key Down (1) events
+    if event.value == 0:
+        if _key_pressed[event.code]:
+            logging.debug(f'FORWARDING {event.code} up')
+            _last_key_up[event.code] = event.sec * 1E6 + event.usec
+            _key_pressed[event.code] = False
+            return True
+        else:
+            logging.info(f'FILTERING {event.code} up: key not pressed beforehand')
+            return False
+
+    prev = _last_key_up.get(event.code)
+    now = event.sec * 1E6 + event.usec
+
+    # DOUBLE-LETTER FIX: Check `_last_key_code != event.code`.
+    # If a user types fast alternating letters (e.g. e -> v -> e), the second 'e' won't be 
+    # mistakenly filtered, because the 'v' reset the _last_key_code.
+    if prev is None or now - prev > threshold * 1E3 or _last_key_code != event.code:
+        logging.debug(f'FORWARDING {event.code} down')
+        _key_pressed[event.code] = True
+        _last_key_code = event.code
+        return True
+
+    logging.info(f'FILTERED {event.code} down: last key up event happened {(now - prev) / 1E3} ms ago')
+    return False
+
+# Global state trackers
+_last_key_up: Dict[libevdev.EventCode, int] = {}
+_key_pressed: DefaultDict[libevdev.EventCode, bool] = defaultdict(bool)
+_last_key_code = None

src/keyboard_main.py

@@ -0,0 +1,64 @@
+import argparse
+import logging
+import sys
+import os
+from contextlib import contextmanager
+import libevdev
+
+from src.keyboard_filtering import filter_chattering
+from src.keyboard_retrieval import retrieve_keyboard_name, INPUT_DEVICES_PATH, abs_keyboard_path
+
+# Safely import the config file if it exists
+try:
+    from src.keyboard_config import FILTERED_KEYS
+except ImportError:
+    FILTERED_KEYS = set()
+
+@contextmanager
+def get_device_handle(keyboard_name: str) -> libevdev.Device:
+    device_path = abs_keyboard_path(keyboard_name)
+
+    # DISCONNECT FIX: Prevent 100% CPU exhaustion loop.
+    # If the keyboard is unplugged/sleeps, the path disappears. We exit cleanly (0).
+    # Systemd (Restart=always) will quietly check every 5 seconds until it returns.
+    if not os.path.exists(device_path):
+        logging.critical(f"Keyboard {keyboard_name} not connected. Exiting to prevent CPU loop.")
+        sys.exit(0)
+
+    fd = open(device_path, 'rb')
+    evdev = libevdev.Device(fd)
+    try:
+        yield evdev
+    finally:
+        fd.close()
+
+def parse_keys(keys_str):
+    """Parses comma-separated CLI arguments into a list of strings."""
+    if not keys_str: return []
+    return [key.strip() for key in keys_str.split(',')]
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-k', '--keyboard', type=str, default=str())
+    parser.add_argument('-t', '--threshold', type=int, default=30)
+    parser.add_argument('--keys', type=parse_keys, default=[])
+    parser.add_argument('-v', '--verbosity', type=int, default=1, choices=[0, 1, 2])
+    args = parser.parse_args()
+
+    logging.basicConfig(level={0: logging.CRITICAL, 1: logging.INFO, 2: logging.DEBUG}[args.verbosity],
+                        handlers=[logging.StreamHandler(sys.stdout)],
+                        format="%(asctime)s - %(message)s", datefmt="%H:%M:%S")
+
+    # CONFIG PRECEDENCE: CLI args > keyboard_config.py > Empty (Filter All)
+    keys_list = args.keys if args.keys else list(FILTERED_KEYS)
+    keys_to_filter = []
+
+    # Convert string key names (e.g., "KEY_A") to libevdev.EventCode objects
+    for key in keys_list:
+        try:
+            keys_to_filter.append(libevdev.evbit(key))
+        except Exception as e:
+            logging.warning(f"Key '{key}' ignored: {e}")
+
+    with get_device_handle(args.keyboard or retrieve_keyboard_name()) as device:
+        filter_chattering(device, args.threshold, keys_to_filter)