evdev 1.9.2__tar.gz → 2.0.0__tar.gz

evdev-2.0.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: evdev
+Version: 2.0.0
+Summary: Bindings to the Linux input handling subsystem
+Author-email: Georgi Valkov <georgi.t.valkov@gmail.com>
+Maintainer-email: Tobi <proxima@sezanzeb.de>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/gvalkov/python-evdev
+Keywords: evdev,input,uinput
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# evdev
+
+<p>
+    <a href="https://pypi.org/pypi/evdev"><img alt="pypi version" src="https://img.shields.io/pypi/v/evdev.svg"></a>
+    <a href="https://github.com/gvalkov/python-evdev/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/pypi/l/evdev"></a>
+    <a href="https://repology.org/project/python%3Aevdev/versions">
+        <img src="https://repology.org/badge/tiny-repos/python%3Aevdev.svg" alt="Packaging status">
+    </a>
+</p>
+
+This package provides bindings to the generic input event interface in Linux.
+The *evdev* interface serves the purpose of passing events generated in the
+kernel directly to userspace through character devices that are typically
+located in `/dev/input/`.
+
+This package also comes with bindings to *uinput*, the userspace input
+subsystem. *Uinput* allows userspace programs to create and handle input devices
+that can inject events directly into the input subsystem.
+
+***Documentation:***
+https://python-evdev.readthedocs.io/en/latest/
+
+***Development:***
+https://github.com/gvalkov/python-evdev
+
+***Package:***
+https://pypi.org/pypi/evdev
+
+***Changelog:***
+https://python-evdev.readthedocs.io/en/latest/changelog.html

{evdev-1.9.2 → evdev-2.0.0}/README.md

@@ -1,9 +1,11 @@
 # evdev
 
 <p>
-    <a href="https://pypi.python.org/pypi/evdev"><img alt="pypi version" src="https://img.shields.io/pypi/v/evdev.svg"></a>
+    <a href="https://pypi.org/pypi/evdev"><img alt="pypi version" src="https://img.shields.io/pypi/v/evdev.svg"></a>
     <a href="https://github.com/gvalkov/python-evdev/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/pypi/l/evdev"></a>
-    <a href="https://repology.org/project/python:evdev/versions"><img alt="Packaging status" src="https://repology.org/badge/tiny-repos/python:evdev.svg"></a>
+    <a href="https://repology.org/project/python%3Aevdev/versions">
+        <img src="https://repology.org/badge/tiny-repos/python%3Aevdev.svg" alt="Packaging status">
+    </a>
 </p>
 
 This package provides bindings to the generic input event interface in Linux.
@@ -15,14 +17,14 @@ This package also comes with bindings to *uinput*, the userspace input
 subsystem. *Uinput* allows userspace programs to create and handle input devices
 that can inject events directly into the input subsystem.
 
-***Documentation:***  
+***Documentation:***
 https://python-evdev.readthedocs.io/en/latest/
 
-***Development:***  
+***Development:***
 https://github.com/gvalkov/python-evdev
 
-***Package:***  
-https://pypi.python.org/pypi/evdev
+***Package:***
+https://pypi.org/pypi/evdev
 
-***Changelog:***  
-https://python-evdev.readthedocs.io/en/latest/changelog.html
+***Changelog:***
+https://python-evdev.readthedocs.io/en/latest/changelog.html

{evdev-1.9.2 → evdev-2.0.0}/pyproject.toml

@@ -1,15 +1,15 @@
 [build-system]
-requires = ["setuptools>=61.0"]
+requires = ["setuptools>=77.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "evdev"
-version = "1.9.2"
+version = "2.0.0"
 description = "Bindings to the Linux input handling subsystem"
 keywords = ["evdev", "input", "uinput"]
 readme = "README.md"
-license = {file = "LICENSE"}
-requires-python = ">=3.8"
+license = "BSD-3-Clause"
+requires-python = ">=3.11"
 authors = [
   { name="Georgi Valkov", email="georgi.t.valkov@gmail.com" },
 ]
@@ -22,7 +22,6 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Intended Audience :: Developers",
     "Topic :: Software Development :: Libraries",
-    "License :: OSI Approved :: BSD License",
     "Programming Language :: Python :: Implementation :: CPython",
 ]
 
@@ -35,18 +34,6 @@ line-length = 120
 [tool.ruff.lint]
 ignore = ["E265", "E241", "F403", "F401", "E401", "E731"]
 
-[tool.bumpversion]
-current_version = "1.9.2"
-commit = true
-tag = true
-allow_dirty = true
-
-[[tool.bumpversion.files]]
-filename = "pyproject.toml"
-
-[[tool.bumpversion.files]]
-filename = "docs/conf.py"
-
 [tool.pylint.'MESSAGES CONTROL']
 disable = """
     no-member,
@@ -55,3 +42,18 @@ disable = """
 [tool.pylint.typecheck]
 generated-members = ["evdev.ecodes.*"]
 ignored-modules= ["evdev._*"]
+
+[dependency-groups]
+dev = [
+    "build>=1.5.0",
+    "cibuildwheel>=2.23.4",
+    "furo>=2025.12.19",
+    "pytest>=9.1.1",
+    "ruff>=0.16.4",
+    "setuptools>=82.0.1",
+    "sphinx>=9.0.4",
+    "sphinx-autobuild>=2025.8.25",
+    "sphinx-autodoc-typehints>=2.3.0",
+    "sphinx-copybutton>=0.5.2",
+    "twine>=7.0.0",
+]

{evdev-1.9.2 → evdev-2.0.0}/src/evdev/device.py

@@ -1,15 +1,15 @@
 import contextlib
 import os
-from typing import Dict, Generic, Iterator, List, Literal, NamedTuple, Tuple, TypeVar, Union, overload
+from typing import Generic, Iterator, Literal, NamedTuple, AnyStr, overload
 
-from . import _input, ecodes, util
+from . import _input, ecodes, ff, util
 
 try:
     from .eventio_async import EvdevError, EventIO
 except ImportError:
     from .eventio import EvdevError, EventIO
 
-_AnyStr = TypeVar("_AnyStr", str, bytes)
+PathLike = AnyStr | os.PathLike[AnyStr]
 
 
 class AbsInfo(NamedTuple):
@@ -58,7 +58,7 @@ class AbsInfo(NamedTuple):
     flat: int
     resolution: int
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "value {}, min {}, max {}, fuzz {}, flat {}, res {}".format(*self)  # pylint: disable=not-an-iterable
 
 
@@ -78,7 +78,7 @@ class KbdInfo(NamedTuple):
     delay: int
     repeat: int
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "delay {}, repeat {}".format(self.delay, self.repeat)
 
 
@@ -102,26 +102,31 @@ class DeviceInfo(NamedTuple):
         return msg.format(*self)  # pylint: disable=not-an-iterable
 
 
-class InputDevice(EventIO, Generic[_AnyStr]):
+class InputDevice(EventIO, Generic[AnyStr]):
     """
     A linux input device from which input events can be read.
     """
 
     __slots__ = ("path", "fd", "info", "name", "phys", "uniq", "_rawcapabilities", "version", "ff_effects_count")
 
-    def __init__(self, dev: Union[_AnyStr, "os.PathLike[_AnyStr]"]):
+    def __init__(self, dev: PathLike, readonly: bool = False):
         """
         Arguments
         ---------
-        dev : str|bytes|PathLike
+        dev :
           Path to input device
+        readonly : bool
+          Open in read-only mode (``O_RDONLY``) without attempting ``O_RDWR`` first.
         """
 
         #: Path to input device.
-        self.path: _AnyStr = dev if not hasattr(dev, "__fspath__") else dev.__fspath__()
+        self.path: str | bytes = dev if not hasattr(dev, "__fspath__") else dev.__fspath__()
 
-        # Certain operations are possible only when the device is opened in read-write mode.
         try:
+            # Certain operations are possible only when the device is opened in read-write mode.
+            # This avoids triggering firmware side-effects (such as LED state re-assertion) on certain hardware.
+            if readonly:
+                raise OSError
             fd = os.open(dev, os.O_RDWR | os.O_NONBLOCK)
         except OSError:
             fd = os.open(dev, os.O_RDONLY | os.O_NONBLOCK)
@@ -133,7 +138,7 @@ class InputDevice(EventIO, Generic[_AnyStr]):
         info_res = _input.ioctl_devinfo(self.fd)
 
         #: A :class:`DeviceInfo <evdev.device.DeviceInfo>` instance.
-        self.info = DeviceInfo(*info_res[:4])
+        self.info: DeviceInfo = DeviceInfo(*info_res[:4])
 
         #: The name of the event device.
         self.name: str = info_res[4]
@@ -179,21 +184,23 @@ class InputDevice(EventIO, Generic[_AnyStr]):
         return res
 
     @overload
-    def capabilities(self, verbose: Literal[False] = ..., absinfo: bool = ...) -> Dict[int, List[int]]:
+    def capabilities(self, verbose: Literal[False] = ..., absinfo: bool = ...) -> dict[int, list[int]]:
         ...
     @overload
-    def capabilities(self, verbose: Literal[True], absinfo: bool = ...) -> Dict[Tuple[str, int], List[Tuple[str, int]]]:
+    def capabilities(self, verbose: Literal[True], absinfo: bool = ...) -> dict[tuple[str, int], list[tuple[str, int]]]:
         ...
-    def capabilities(self, verbose: bool = False, absinfo: bool = True) -> Union[Dict[int, List[int]], Dict[Tuple[str, int], List[Tuple[str, int]]]]:
+    def capabilities(
+        self, verbose: bool = False, absinfo: bool = True
+    ) -> dict[int, list[int]] | dict[tuple[str, int], list[tuple[str, int]]]:
         """
         Return the event types that this device supports as a mapping of
         supported event types to lists of handled event codes.
 
         Example
         --------
+
         >>> device.capabilities()
-        { 1: [272, 273, 274],
-          2: [0, 1, 6, 8] }
+        { 1: [272, 273, 274], 2: [0, 1, 6, 8] }
 
         If ``verbose`` is ``True``, event codes and types will be resolved
         to their names.
@@ -281,7 +288,7 @@ class InputDevice(EventIO, Generic[_AnyStr]):
         """
         self.write(ecodes.EV_LED, led_num, value)
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         """
         Two devices are equal if their :data:`info` attributes are equal.
         """
@@ -295,7 +302,7 @@ class InputDevice(EventIO, Generic[_AnyStr]):
         msg = (self.__class__.__name__, self.path)
         return "{}({!r})".format(*msg)
 
-    def __fspath__(self):
+    def __fspath__(self) -> AnyStr:
         return self.path
 
     def close(self) -> None:
@@ -341,16 +348,19 @@ class InputDevice(EventIO, Generic[_AnyStr]):
         yield
         self.ungrab()
 
-    def upload_effect(self, effect: "ff.Effect"):
+    def upload_effect(self, effect: "ff.Effect", writeback_id: bool = True) -> int:
         """
-        Upload a force feedback effect to a force feedback device.
+        Upload a force feedback effect to a force feedback device and return its effect id.
+        If ``writeback_id`` is ``True``, the effect id is written back to the ``effect`` struct.
         """
 
         data = memoryview(effect).tobytes()
         ff_id = _input.upload_effect(self.fd, data)
+        if writeback_id:
+            effect.id = ff_id
         return ff_id
 
-    def erase_effect(self, ff_id) -> None:
+    def erase_effect(self, ff_id: int) -> None:
         """
         Erase a force effect from a force feedback device. This also
         stops the effect.
@@ -368,7 +378,7 @@ class InputDevice(EventIO, Generic[_AnyStr]):
         return KbdInfo(*_input.ioctl_EVIOCGREP(self.fd))
 
     @repeat.setter
-    def repeat(self, value: Tuple[int, int]):
+    def repeat(self, value: tuple[int, int]):
         return _input.ioctl_EVIOCSREP(self.fd, *value)
 
     def active_keys(self, verbose: bool = False):
@@ -410,7 +420,16 @@ class InputDevice(EventIO, Generic[_AnyStr]):
         """
         return AbsInfo(*_input.ioctl_EVIOCGABS(self.fd, axis_num))
 
-    def set_absinfo(self, axis_num: int, value=None, min=None, max=None, fuzz=None, flat=None, resolution=None) -> None:
+    def set_absinfo(
+        self,
+        axis_num: int,
+        value: int | None = None,
+        min: int | None = None,
+        max: int | None = None,
+        fuzz: int | None = None,
+        flat: int | None = None,
+        resolution: int | None = None,
+    ) -> None:
         """
         Update :class:`AbsInfo` values. Only specified values will be overwritten.
 

{evdev-1.9.2 → evdev-2.0.0}/src/evdev/eventio.py

@@ -2,7 +2,7 @@ import fcntl
 import functools
 import os
 import select
-from typing import Iterator, Union
+from typing import Iterator, Callable
 
 from . import _input, _uinput, ecodes
 from .events import InputEvent
@@ -28,7 +28,7 @@ class EventIO:
       beeps).
     """
 
-    def fileno(self):
+    def fileno(self) -> int:
         """
         Return the file descriptor to the open event device. This makes
         it possible to pass instances directly to :func:`select.select()` and
@@ -46,7 +46,7 @@ class EventIO:
             for event in self.read():
                 yield event
 
-    def read_one(self) -> Union[InputEvent, None]:
+    def read_one(self) -> InputEvent | None:
         """
         Read and return a single input event as an instance of
         :class:`InputEvent <evdev.events.InputEvent>`.
@@ -74,7 +74,7 @@ class EventIO:
             yield InputEvent(*event)
 
     # pylint: disable=no-self-argument
-    def need_write(func):
+    def need_write(func: Callable) -> Callable:
         """
         Decorator that raises :class:`EvdevError` if there is no write access to the
         input device.
@@ -91,7 +91,7 @@ class EventIO:
 
         return wrapper
 
-    def write_event(self, event):
+    def write_event(self, event: InputEvent):
         """
         Inject an input event into the input subsystem. Events are
         queued until a synchronization event is received.
@@ -139,7 +139,7 @@ class EventIO:
 
         _uinput.write(self.fd, etype, code, value)
 
-    def syn(self):
+    def syn(self) -> None:
         """
         Inject a ``SYN_REPORT`` event into the input subsystem. Events
         queued by :func:`write()` will be fired. If possible, events
@@ -148,5 +148,5 @@ class EventIO:
 
         self.write(ecodes.EV_SYN, ecodes.SYN_REPORT, 0)
 
-    def close(self):
+    def close(self) -> None:
         pass

{evdev-1.9.2 → evdev-2.0.0}/src/evdev/eventio_async.py

@@ -15,7 +15,7 @@ else:
 
 
 class ReadIterator:
-    def __init__(self, device):
+    def __init__(self, device: "EventIO"):
         self.current_batch = iter(())
         self.device = device
 
@@ -36,7 +36,7 @@ class ReadIterator:
         return self
 
     def __anext__(self) -> "asyncio.Future[InputEvent]":
-        future = asyncio.Future()
+        future = asyncio.get_running_loop().create_future()
         try:
             # Read from the previous batch of events.
             future.set_result(next(self.current_batch))
@@ -54,8 +54,15 @@ class ReadIterator:
 
 
 class EventIO(eventio.EventIO):
-    def _do_when_readable(self, callback):
-        loop = asyncio.get_event_loop()
+    # The event loop a reader was last registered on, or None if no async read
+    # has been awaited yet. Set in _do_when_readable, used by close().
+    _loop: "asyncio.AbstractEventLoop | None" = None
+
+    def _do_when_readable(self, callback) -> None:
+        # Remember the loop the reader is registered on so that close() can
+        # remove it later, even when called without a running event loop.
+        loop = asyncio.get_running_loop()
+        self._loop = loop
 
         def ready():
             loop.remove_reader(self.fileno())
@@ -63,28 +70,28 @@ class EventIO(eventio.EventIO):
 
         loop.add_reader(self.fileno(), ready)
 
-    def _set_result(self, future, cb):
+    def _set_result(self, future, cb) -> None:
         try:
             future.set_result(cb())
         except Exception as error:
             future.set_exception(error)
 
-    def async_read_one(self):
+    def async_read_one(self) -> "asyncio.Future[InputEvent]":
         """
         Asyncio coroutine to read and return a single input event as
         an instance of :class:`InputEvent <evdev.events.InputEvent>`.
         """
-        future = asyncio.Future()
+        future = asyncio.get_running_loop().create_future()
         self._do_when_readable(lambda: self._set_result(future, self.read_one))
         return future
 
-    def async_read(self):
+    def async_read(self) -> "asyncio.Future[InputEvent]":
         """
         Asyncio coroutine to read multiple input events from device. Return
         a generator object that yields :class:`InputEvent <evdev.events.InputEvent>`
         instances.
         """
-        future = asyncio.Future()
+        future = asyncio.get_running_loop().create_future()
         self._do_when_readable(lambda: self._set_result(future, self.read))
         return future
 
@@ -96,11 +103,12 @@ class EventIO(eventio.EventIO):
         """
         return ReadIterator(self)
 
-    def close(self):
-        try:
-            loop = asyncio.get_event_loop()
-            loop.remove_reader(self.fileno())
-        except RuntimeError:
-            # no event loop present, so there is nothing to
-            # remove the reader from. Ignore
-            pass
+    def close(self) -> None:
+        # A reader is only registered once an async read has been awaited, in
+        # which case _do_when_readable recorded the loop it was added to.
+        loop = self._loop
+        if loop is None or loop.is_closed():
+            # No reader was ever registered, or its loop is already gone, so
+            # there is nothing to remove the reader from.
+            return
+        loop.remove_reader(self.fileno())

{evdev-1.9.2 → evdev-2.0.0}/src/evdev/events.py

@@ -47,7 +47,7 @@ class InputEvent:
 
     __slots__ = "sec", "usec", "type", "code", "value"
 
-    def __init__(self, sec, usec, type, code, value):
+    def __init__(self, sec: int, usec: int, type: int, code: int, value: int):
         #: Time in seconds since epoch at which event occurred.
         self.sec: int = sec
 
@@ -67,11 +67,11 @@ class InputEvent:
         """Return event timestamp as a float."""
         return self.sec + (self.usec / 1000000.0)
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = "event at {:f}, code {:02d}, type {:02d}, val {:02d}"
         return msg.format(self.timestamp(), self.code, self.type, self.value)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         msg = "{}({!r}, {!r}, {!r}, {!r}, {!r})"
         return msg.format(self.__class__.__name__, self.sec, self.usec, self.type, self.code, self.value)
 
@@ -95,24 +95,24 @@ class KeyEvent:
         self.scancode: int = event.code
 
         if event.value == 0:
-            self.keystate = KeyEvent.key_up
+            self.keystate: int = KeyEvent.key_up
         elif event.value == 2:
-            self.keystate = KeyEvent.key_hold
+            self.keystate: int = KeyEvent.key_hold
         elif event.value == 1:
-            self.keystate = KeyEvent.key_down
+            self.keystate: int = KeyEvent.key_down
 
         try:
-            self.keycode = keys[event.code]
+            self.keycode: int = keys[event.code]
         except KeyError:
             if allow_unknown:
-                self.keycode = "0x{:02X}".format(event.code)
+                self.keycode: int = "0x{:02X}".format(event.code)
             else:
                 raise
 
         #: Reference to an :class:`InputEvent` instance.
         self.event: InputEvent = event
 
-    def __str__(self):
+    def __str__(self) -> str:
         try:
             ks = ("up", "down", "hold")[self.keystate]
         except IndexError:
@@ -121,7 +121,7 @@ class KeyEvent:
         msg = "key event at {:f}, {} ({}), {}"
         return msg.format(self.event.timestamp(), self.scancode, self.keycode, ks)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "{}({!r})".format(self.__class__.__name__, self.event)
 
 
@@ -134,11 +134,11 @@ class RelEvent:
         #: Reference to an :class:`InputEvent` instance.
         self.event: InputEvent = event
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = "relative axis event at {:f}, {}"
         return msg.format(self.event.timestamp(), REL[self.event.code])
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "{}({!r})".format(self.__class__.__name__, self.event)
 
 
@@ -151,11 +151,11 @@ class AbsEvent:
         #: Reference to an :class:`InputEvent` instance.
         self.event: InputEvent = event
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = "absolute axis event at {:f}, {}"
         return msg.format(self.event.timestamp(), ABS[self.event.code])
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "{}({!r})".format(self.__class__.__name__, self.event)
 
 
@@ -171,17 +171,17 @@ class SynEvent:
         #: Reference to an :class:`InputEvent` instance.
         self.event: InputEvent = event
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = "synchronization event at {:f}, {}"
         return msg.format(self.event.timestamp(), SYN[self.event.code])
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "{}({!r})".format(self.__class__.__name__, self.event)
 
 
 #: A mapping of event types to :class:`InputEvent` sub-classes. Used
 #: by :func:`evdev.util.categorize()`
-event_factory = {
+event_factory: dict[int, type[InputEvent]] = {
     EV_KEY: KeyEvent,
     EV_REL: RelEvent,
     EV_ABS: AbsEvent,

{evdev-1.9.2 → evdev-2.0.0}/src/evdev/genecodes_c.py

@@ -77,6 +77,9 @@ PyInit__ecodes(void)
 {
     PyObject* m = PyModule_Create(&moduledef);
     if (m == NULL) return NULL;
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
 
 %s
 

evdev-2.0.0/src/evdev/genecodes_py.py

@@ -0,0 +1,54 @@
+import sys
+from unittest import mock
+from pprint import PrettyPrinter
+
+sys.modules["evdev.ecodes"] = mock.Mock()
+from evdev import ecodes_runtime as ecodes
+
+pprint = PrettyPrinter(indent=2, sort_dicts=True, width=120).pprint
+
+
+print("# Automatically generated by evdev.genecodes_py")
+print()
+print('"""')
+print(ecodes.__doc__.strip())
+print('"""')
+
+print()
+print("from typing import Final")
+print()
+
+for name, value in ecodes.ecodes.items():
+    print(f"{name}: Final[int] = {value}")
+print()
+
+entries = [
+    ("ecodes", "dict[str, int]", "#: Mapping of names to values."),
+    ("bytype", "dict[int, dict[int, str | tuple[str]]]", "#: Mapping of event types to other value/name mappings."),
+    ("keys",   "dict[int, str | tuple[str]]", "#: Keys are a combination of all BTN and KEY codes."),
+    ("KEY",    "dict[int, str | tuple[str]]", None),
+    ("ABS",    "dict[int, str | tuple[str]]", None),
+    ("REL",    "dict[int, str | tuple[str]]", None),
+    ("SW",     "dict[int, str | tuple[str]]", None),
+    ("MSC",    "dict[int, str | tuple[str]]", None),
+    ("LED",    "dict[int, str | tuple[str]]", None),
+    ("BTN",    "dict[int, str | tuple[str]]", None),
+    ("REP",    "dict[int, str | tuple[str]]", None),
+    ("SND",    "dict[int, str | tuple[str]]", None),
+    ("ID",     "dict[int, str | tuple[str]]", None),
+    ("EV",     "dict[int, str | tuple[str]]", None),
+    ("BUS",    "dict[int, str | tuple[str]]", None),
+    ("SYN",    "dict[int, str | tuple[str]]", None),
+    ("FF",     "dict[int, str | tuple[str]]", None),
+    ("UI_FF",  "dict[int, str | tuple[str]]", None),
+    ("FF_STATUS",  "dict[int, str | tuple[str]]", None),
+    ("INPUT_PROP", "dict[int, str | tuple[str]]", None)
+]
+
+for key, annotation, doc in entries:
+    if doc:
+        print(doc)
+
+    print(f"{key}: {annotation} = ", end="")
+    pprint(getattr(ecodes, key))
+    print()