evdev 1.9.3__tar.gz → 2.0.0__tar.gz

{evdev-1.9.3/src/evdev.egg-info → evdev-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evdev
-Version: 1.9.3
+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>
@@ -13,7 +13,7 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
@@ -21,9 +21,11 @@ Dynamic: license-file
 # 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.
@@ -35,14 +37,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:***  
+***Changelog:***
 https://python-evdev.readthedocs.io/en/latest/changelog.html

{evdev-1.9.3 → 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.3 → evdev-2.0.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evdev"
-version = "1.9.3"
+version = "2.0.0"
 description = "Bindings to the Linux input handling subsystem"
 keywords = ["evdev", "input", "uinput"]
 readme = "README.md"
 license = "BSD-3-Clause"
-requires-python = ">=3.9"
+requires-python = ">=3.11"
 authors = [
   { name="Georgi Valkov", email="georgi.t.valkov@gmail.com" },
 ]
@@ -34,18 +34,6 @@ line-length = 120
 [tool.ruff.lint]
 ignore = ["E265", "E241", "F403", "F401", "E401", "E731"]
 
-[tool.bumpversion]
-current_version = "1.9.3"
-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,
@@ -54,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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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()

{evdev-1.9.3 → evdev-2.0.0}/src/evdev/input.c

@@ -24,6 +24,14 @@
 #include <linux/input.h>
 #endif
 
+#if defined(Py_GIL_DISABLED)
+    #define MAYBE_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
+    #define MAYBE_END_ALLOW_THREADS   Py_END_ALLOW_THREADS
+#else
+    #define MAYBE_BEGIN_ALLOW_THREADS
+    #define MAYBE_END_ALLOW_THREADS
+#endif
+
 #ifndef input_event_sec
 #define input_event_sec time.tv_sec
 #define input_event_usec time.tv_usec
@@ -51,7 +59,10 @@ device_read(PyObject *self, PyObject *args)
     // get device file descriptor (O_RDONLY|O_NONBLOCK)
     int fd = (int)PyLong_AsLong(PyTuple_GET_ITEM(args, 0));
 
-    int n = read(fd, &event, sizeof(event));
+    int n;
+    MAYBE_BEGIN_ALLOW_THREADS
+    n = read(fd, &event, sizeof(event));
+    MAYBE_END_ALLOW_THREADS
 
     if (n < 0) {
         if (errno == EAGAIN) {
@@ -84,7 +95,10 @@ device_read_many(PyObject *self, PyObject *args)
     struct input_event event[64];
 
     size_t event_size = sizeof(struct input_event);
-    ssize_t nread = read(fd, event, event_size*64);
+    ssize_t nread;
+    MAYBE_BEGIN_ALLOW_THREADS
+    nread = read(fd, event, event_size*64);
+    MAYBE_END_ALLOW_THREADS
 
     if (nread < 0) {
         PyErr_SetFromErrno(PyExc_OSError);
@@ -570,6 +584,9 @@ moduleinit(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
     return m;
 }
 

{evdev-1.9.3 → evdev-2.0.0}/src/evdev/uinput.c

@@ -298,6 +298,25 @@ uinput_write(PyObject *self, PyObject *args)
 }
 
 
+static PyObject *
+uinput_enable_event_type(PyObject *self, PyObject *args)
+{
+    int fd;
+    uint16_t type;
+
+    int ret = PyArg_ParseTuple(args, "ih", &fd, &type);
+    if (!ret) return NULL;
+
+    if (ioctl(fd, UI_SET_EVBIT, type) < 0) {
+        _uinput_close(fd);
+        PyErr_SetFromErrno(PyExc_OSError);
+        return NULL;
+    }
+
+    Py_RETURN_NONE;
+}
+
+
 static PyObject *
 uinput_enable_event(PyObject *self, PyObject *args)
 {
@@ -376,6 +395,9 @@ static PyMethodDef MethodTable[] = {
     { "enable", uinput_enable_event, METH_VARARGS,
       "Enable a type of event."},
 
+    { "enable_type", uinput_enable_event_type, METH_VARARGS,
+      "Enable an event type without enabling an event code."},
+
     { "set_phys", uinput_set_phys, METH_VARARGS,
       "Set physical path"},
 
@@ -405,7 +427,9 @@ moduleinit(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
     PyModule_AddIntConstant(m, "maxnamelen", UINPUT_MAX_NAME_SIZE);
     return m;
 }

{evdev-1.9.3 → evdev-2.0.0}/src/evdev/uinput.py

@@ -5,7 +5,7 @@ import re
 import stat
 import time
 from collections import defaultdict
-from typing import Union, Tuple, Dict, Sequence, Optional
+from typing import Sequence
 
 from . import _uinput, ecodes, ff, util
 from .device import InputDevice, AbsInfo
@@ -42,10 +42,10 @@ class UInput(EventIO):
     @classmethod
     def from_device(
         cls,
-        *devices: Union[InputDevice, Union[str, bytes, os.PathLike]],
-        filtered_types: Tuple[int] = (ecodes.EV_SYN, ecodes.EV_FF),
+        *devices: InputDevice | str | bytes | os.PathLike,
+        filtered_types: tuple[int] = (ecodes.EV_SYN, ecodes.EV_FF),
         **kwargs,
-    ):
+    ) -> "UInput":
         """
         Create an UInput device with the capabilities of one or more input
         devices.
@@ -86,7 +86,7 @@ class UInput(EventIO):
 
     def __init__(
         self,
-        events: Optional[Dict[int, Sequence[int]]] = None,
+        events: dict[int, Sequence[int]] | None = None,
         name: str = "py-evdev-uinput",
         vendor: int = 0x1,
         product: int = 0x1,
@@ -94,11 +94,11 @@ class UInput(EventIO):
         bustype: int = 0x3,
         devnode: str = "/dev/uinput",
         phys: str = "py-evdev-uinput",
-        input_props=None,
+        input_props: Sequence[int] | None = None,
         # CentOS 7 has sufficiently old headers that FF_MAX_EFFECTS is not defined there,
         # which causes the whole module to fail loading. Fallback on a hardcoded value of
         # FF_MAX_EFFECTS if it is not defined in the ecodes.
-        max_effects=ecodes.ecodes.get("FF_MAX_EFFECTS", 96),
+        max_effects: int = ecodes.ecodes.get("FF_MAX_EFFECTS", 96),
     ):
         """
         Arguments
@@ -106,7 +106,9 @@ class UInput(EventIO):
         events : dict
           Dictionary of event types mapping to lists of event codes. The
           event types and codes that the uinput device will be able to
-          inject - defaults to all key codes.
+          inject - defaults to all key codes. An event type mapped to an
+          empty sequence enables the event type without enabling any event
+          codes, which is useful for types such as ``EV_REP``.
 
         name
           The name of the input device.
@@ -165,6 +167,10 @@ class UInput(EventIO):
         for prop in input_props:
             _uinput.set_prop(self.fd, prop)
 
+        for etype, codes in events.items():
+            if not codes:
+                _uinput.enable_type(self.fd, etype)
+
         for etype, code in prepared_events:
             _uinput.enable(self.fd, etype, code)
 
@@ -182,7 +188,7 @@ class UInput(EventIO):
         #: opened for reading and writing.
         self.device: InputDevice = self._find_device(self.fd)
 
-    def _prepare_events(self, events):
+    def _prepare_events(self, events: dict[int, Sequence[int]]):
         """Prepare events for passing to _uinput.enable and _uinput.setup"""
         absinfo, prepared_events = [], []
         for etype, codes in events.items():
@@ -200,19 +206,19 @@ class UInput(EventIO):
                 prepared_events.append((etype, code))
         return absinfo, prepared_events
 
-    def __enter__(self):
+    def __enter__(self) -> "UInput":
         return self
 
-    def __exit__(self, type, value, tb):
+    def __exit__(self, type, value, tb) -> None:
         if hasattr(self, "fd"):
             self.close()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         # TODO:
         v = (repr(getattr(self, i)) for i in ("name", "bustype", "vendor", "product", "version", "phys"))
         return "{}({})".format(self.__class__.__name__, ", ".join(v))
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = 'name "{}", bus "{}", vendor "{:04x}", product "{:04x}", version "{:04x}", phys "{}"\nevent types: {}'
 
         evtypes = [i[0] for i in self.capabilities(True).keys()]
@@ -222,7 +228,7 @@ class UInput(EventIO):
 
         return msg
 
-    def close(self):
+    def close(self) -> None:
         # Close the associated InputDevice, if it was previously opened.
         if self.device is not None:
             self.device.close()
@@ -232,14 +238,14 @@ class UInput(EventIO):
             _uinput.close(self.fd)
             self.fd = -1
 
-    def capabilities(self, verbose: bool = False, absinfo: bool = True):
+    def capabilities( self, verbose: bool = False, absinfo: bool = True):
         """See :func:`capabilities <evdev.device.InputDevice.capabilities>`."""
         if self.device is None:
             raise UInputError("input device not opened - cannot read capabilities")
 
         return self.device.capabilities(verbose, absinfo)
 
-    def begin_upload(self, effect_id):
+    def begin_upload(self, effect_id: int) -> ff.UInputUpload:
         upload = ff.UInputUpload()
         upload.effect_id = effect_id
 
@@ -249,12 +255,12 @@ class UInput(EventIO):
 
         return upload
 
-    def end_upload(self, upload):
+    def end_upload(self, upload: ff.UInputUpload) -> None:
         ret = self.dll._uinput_end_upload(self.fd, ctypes.byref(upload))
         if ret:
             raise UInputError("Failed to end uinput upload: " + os.strerror(ret))
 
-    def begin_erase(self, effect_id):
+    def begin_erase(self, effect_id: int) -> ff.UInputErase:
         erase = ff.UInputErase()
         erase.effect_id = effect_id
 
@@ -263,12 +269,12 @@ class UInput(EventIO):
             raise UInputError("Failed to begin uinput erase: " + os.strerror(ret))
         return erase
 
-    def end_erase(self, erase):
+    def end_erase(self, erase: ff.UInputErase) -> None:
         ret = self.dll._uinput_end_erase(self.fd, ctypes.byref(erase))
         if ret:
             raise UInputError("Failed to end uinput erase: " + os.strerror(ret))
 
-    def _verify(self):
+    def _verify(self) -> None:
         """
         Verify that an uinput device exists and is readable and writable
         by the current process.
@@ -342,7 +348,7 @@ class UInput(EventIO):
         # shall be the exception that this function raises.
         return InputDevice(device_path)
 
-    def _find_device_fallback(self) -> Union[InputDevice, None]:
+    def _find_device_fallback(self) -> InputDevice | None:
         """
         Tries to find the device node when UI_GET_SYSNAME is not available or
         we're running on a system sufficiently exotic that we do not know how

{evdev-1.9.3 → evdev-2.0.0}/src/evdev/util.py

@@ -3,21 +3,28 @@ import glob
 import os
 import re
 import stat
-from typing import Union, List
 
 from . import ecodes
 from .events import InputEvent, event_factory, KeyEvent, RelEvent, AbsEvent, SynEvent
 
 
-def list_devices(input_device_dir: Union[str, bytes, os.PathLike] = "/dev/input") -> List[str]:
-    """List readable character devices in ``input_device_dir``."""
+def list_devices(input_device_dir: str | bytes | os.PathLike = "/dev/input", writable: bool = True) -> list[str]:
+    """List readable (and optionally writable) character devices in ``input_device_dir``.
+
+    Arguments
+    ---------
+    input_device_dir
+      Path to the input device directory. Default is ``/dev/input``.
+    writable
+      Only list devices that are both readable and writable.
+    """
 
     fns = glob.glob("{}/event*".format(input_device_dir))
-    return list(filter(is_device, fns))
+    return [fn for fn in fns if is_device(fn, writable=writable)]
 
 
-def is_device(fn: Union[str, bytes, os.PathLike]) -> bool:
-    """Check if ``fn`` is a readable and writable character device."""
+def is_device(fn: str | bytes | os.PathLike, writable: bool = True) -> bool:
+    """Check if ``fn`` is a readable (and optionally writable) character device."""
 
     if not os.path.exists(fn):
         return False
@@ -26,13 +33,14 @@ def is_device(fn: Union[str, bytes, os.PathLike]) -> bool:
     if not stat.S_ISCHR(m):
         return False
 
-    if not os.access(fn, os.R_OK | os.W_OK):
+    access = (os.R_OK | os.W_OK) if writable else os.R_OK
+    if not os.access(fn, access):
         return False
 
     return True
 
 
-def categorize(event: InputEvent) -> Union[InputEvent, KeyEvent, RelEvent, AbsEvent, SynEvent]:
+def categorize(event: InputEvent) -> InputEvent | KeyEvent | RelEvent | AbsEvent | SynEvent:
     """
     Categorize an event according to its type.
 

{evdev-1.9.3 → evdev-2.0.0/src/evdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evdev
-Version: 1.9.3
+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>
@@ -13,7 +13,7 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
@@ -21,9 +21,11 @@ Dynamic: license-file
 # 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.
@@ -35,14 +37,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:***  
+***Changelog:***
 https://python-evdev.readthedocs.io/en/latest/changelog.html

{evdev-1.9.3 → evdev-2.0.0}/tests/test_uinput.py

@@ -67,6 +67,16 @@ def test_enable_events(c):
         assert sorted(cap[e.EV_KEY]) == sorted(c["events"][e.EV_KEY])
 
 
+def test_enable_event_type_without_codes(c):
+    e = ecodes
+    c["events"] = {e.EV_KEY: [e.KEY_A], e.EV_REP: []}
+
+    with uinput.UInput(**c) as ui:
+        repeat = ui.device.repeat
+        assert repeat.delay > 0
+        assert repeat.repeat > 0
+
+
 def test_abs_values(c):
     e = ecodes
     c = {

evdev-1.9.3/src/evdev/genecodes_py.py

@@ -1,54 +0,0 @@
-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, Dict, Tuple, Union")
-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, Union[str, Tuple[str]]]]", "#: Mapping of event types to other value/name mappings."),
-    ("keys",   "Dict[int, Union[str, Tuple[str]]]", "#: Keys are a combination of all BTN and KEY codes."),
-    ("KEY",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("ABS",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("REL",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("SW",     "Dict[int, Union[str, Tuple[str]]]", None),
-    ("MSC",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("LED",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("BTN",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("REP",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("SND",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("ID",     "Dict[int, Union[str, Tuple[str]]]", None),
-    ("EV",     "Dict[int, Union[str, Tuple[str]]]", None),
-    ("BUS",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("SYN",    "Dict[int, Union[str, Tuple[str]]]", None),
-    ("FF",     "Dict[int, Union[str, Tuple[str]]]", None),
-    ("UI_FF",  "Dict[int, Union[str, Tuple[str]]]", None),
-    ("FF_STATUS",  "Dict[int, Union[str, Tuple[str]]]", None),
-    ("INPUT_PROP", "Dict[int, Union[str, Tuple[str]]]", None)
-]
-
-for key, annotation, doc in entries:
-    if doc:
-        print(doc)
-
-    print(f"{key}: {annotation} = ", end="")
-    pprint(getattr(ecodes, key))
-    print()