Add CI workflow with lint + headless test subset across 3 OS

.github/workflows/ci.yml

@@ -0,0 +1,62 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.13'
+      - run: pip install ruff
+      - name: ruff format --check
+        run: |
+          ruff format --check \
+            --config 'format.quote-style="preserve"' \
+            --config 'line-length=80' \
+            lib/pynput tests
+
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python: ['3.10', '3.11', '3.12', '3.13']
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Install pynput
+        run: pip install -e .
+      - name: Install Linux backend deps
+        if: runner.os == 'Linux'
+        run: pip install evdev python-xlib
+      - name: Run headless test subset
+        env:
+          # Tests in this subset don't synthesize OS input and don't wait
+          # for human input via self.confirm() — safe to run on a CI runner.
+          # The rest of the suite needs a real interactive session.
+          PYNPUT_TESTS: >-
+            tests.keyboard_hotkey_tests.KeyboardHotKeyTest.test_parse_valid
+            tests.keyboard_hotkey_tests.KeyboardHotKeyTest.test_parse_invalid
+            tests.keyboard_hotkey_tests.KeyboardHotKeyTest.test_activate_single
+            tests.keyboard_hotkey_tests.KeyboardHotKeyTest.test_activate_combo
+            tests.mouse_controller_tests.MouseControllerTest.test_buttons
+            tests.keyboard_controller_tests.KeyboardControllerTest.test_keys
+            tests.keyboard_controller_tests.KeyboardControllerTest.test_press_invalid
+            tests.keyboard_controller_tests.KeyboardControllerTest.test_release_invalid
+        shell: bash
+        run: |
+          if [ "$RUNNER_OS" = "Linux" ]; then
+            xvfb-run -a python -m unittest $PYNPUT_TESTS
+          else
+            python -m unittest $PYNPUT_TESTS
+          fi

lib/pynput/_info.py

@@ -15,5 +15,5 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
-__author__ = u'Moses Palmér'
+__author__ = 'Moses Palmér'
 __version__ = (1, 8, 2)

tests/__init__.py

@@ -62,8 +62,11 @@ def notify(message, delay=None, columns=50):
         if lines:
             lines.append('')
         for word in line.split():
-            if not lines or not lines[-1] \
-                    or len(lines[-1]) + 1 + len(word) > max_length:
+            if (
+                not lines
+                or not lines[-1]
+                or len(lines[-1]) + 1 + len(word) > max_length
+            ):
                 lines.append(word)
             else:
                 lines[-1] += ' ' + word
@@ -79,7 +82,6 @@ def notify(message, delay=None, columns=50):
         time.sleep(delay)
 
 
-
 #: A decorator to make a test run only on macOS
 darwin = functools.partial(_backend, 'darwin')
 
@@ -119,7 +121,8 @@ def tearDownClass(self):
         remaining = [
             listener
             for listener in self.listeners
-            if not (listener.join(0.5) or listener.is_alive)]
+            if not (listener.join(0.5) or listener.is_alive)
+        ]
         for listener in remaining:
             listener.join()
 
@@ -152,6 +155,7 @@ def assert_event(self, failure_message, **kwargs):
 
         :param kwargs: Arguments to pass to the listener constructor.
         """
+
         def wrapper(name, callback):
             def inner(*a):
                 if callback(*a):
@@ -160,9 +164,12 @@ def inner(*a):
 
             return inner if callback else None
 
-        with self.listener(**{
+        with self.listener(
+            **{
                 name: wrapper(name, callback)
-                for name, callback in kwargs.items()}) as listener:
+                for name, callback in kwargs.items()
+            }
+        ) as listener:
             time.sleep(0.1)
             listener.success = False
             yield
@@ -172,9 +179,7 @@ def inner(*a):
                 if listener.success:
                     break
 
-        self.assertTrue(
-            listener.success,
-            failure_message)
+        self.assertTrue(listener.success, failure_message)
 
     def assert_stop(self, failure_message, **callbacks):
         """Asserts that a listener stop within :attr:`STOP_MAX_WAIT` seconds.
@@ -195,9 +200,7 @@ def assert_stop(self, failure_message, **callbacks):
                     success = True
                     break
 
-        self.assertTrue(
-            success,
-            failure_message)
+        self.assertTrue(success, failure_message)
 
     def assert_cumulative(self, failure_message, **callbacks):
         """Asserts that the callback returns true for at least two thirds of
@@ -211,9 +214,7 @@ def assert_cumulative(self, failure_message, **callbacks):
             occurred.
         """
         # The lists of accumulated events
-        events = {
-            name: []
-            for name in callbacks}
+        events = {name: [] for name in callbacks}
 
         def wrapper(name, callback):
             def inner(*a):
@@ -222,19 +223,26 @@ def inner(*a):
 
                 total_length = len(cache)
                 if total_length > self.CHANGE_MIN_EVENTS:
-                    change_length = len([
-                        None
-                        for i, b in enumerate(cache[1:])
-                        if callback(cache[i], b)])
+                    change_length = len(
+                        [
+                            None
+                            for i, b in enumerate(cache[1:])
+                            if callback(cache[i], b)
+                        ]
+                    )
 
                     if change_length > (2 * total_length) / 3:
                         return False
 
             return inner if callback else None
 
-        self.assert_stop(failure_message, **{
-            name: wrapper(name, callback)
-            for name, callback in callbacks.items()})
+        self.assert_stop(
+            failure_message,
+            **{
+                name: wrapper(name, callback)
+                for name, callback in callbacks.items()
+            },
+        )
 
     def confirm(self, statement, *fmt):
         """Asks the user to confirm a statement.
@@ -251,10 +259,13 @@ def confirm(self, statement, *fmt):
             response = input(message)
             if response.lower() in valid_responses:
                 self.assertIn(
-                    response.lower(), accept_responses,
-                    'User declined statement "%s"' % message)
+                    response.lower(),
+                    accept_responses,
+                    'User declined statement "%s"' % message,
+                )
                 return
             else:
                 print(
-                    'Please respond %s' % ', '.join(
-                        '"%s"' % r for r in valid_responses))
+                    'Please respond %s'
+                    % ', '.join('"%s"' % r for r in valid_responses)
+                )