evdev 1.9.0__tar.gz → 1.9.2__tar.gz

{evdev-1.9.0/src/evdev.egg-info → evdev-1.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: evdev
-Version: 1.9.0
+Version: 1.9.2
 Summary: Bindings to the Linux input handling subsystem
 Author-email: Georgi Valkov <georgi.t.valkov@gmail.com>
 Maintainer-email: Tobi <proxima@sezanzeb.de>
@@ -46,6 +46,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 # evdev
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evdev"
-version = "1.9.0"
+version = "1.9.2"
 description = "Bindings to the Linux input handling subsystem"
 keywords = ["evdev", "input", "uinput"]
 readme = "README.md"
@@ -36,7 +36,7 @@ line-length = 120
 ignore = ["E265", "E241", "F403", "F401", "E401", "E731"]
 
 [tool.bumpversion]
-current_version = "1.9.0"
+current_version = "1.9.2"
 commit = true
 tag = true
 allow_dirty = true

{evdev-1.9.0 → evdev-1.9.2}/setup.py

@@ -14,7 +14,7 @@ curdir = Path(__file__).resolve().parent
 ecodes_c_path = curdir / "src/evdev/ecodes.c"
 
 
-def create_ecodes(headers=None):
+def create_ecodes(headers=None, reproducible=False):
     if not headers:
         include_paths = set()
         cpath = os.environ.get("CPATH", "").strip()
@@ -65,7 +65,10 @@ def create_ecodes(headers=None):
 
     print("writing %s (using %s)" % (ecodes_c_path, " ".join(headers)))
     with ecodes_c_path.open("w") as fh:
-        cmd = [sys.executable, "src/evdev/genecodes_c.py", "--ecodes", *headers]
+        cmd = [sys.executable, "src/evdev/genecodes_c.py"]
+        if reproducible:
+            cmd.append("--reproducible")
+        cmd.extend(["--ecodes", *headers])
         run(cmd, check=True, stdout=fh)
 
 
@@ -74,17 +77,21 @@ class build_ecodes(Command):
 
     user_options = [
         ("evdev-headers=", None, "colon-separated paths to input subsystem headers"),
+        ("reproducible", None, "hide host details (host/paths) to create a reproducible output"),
     ]
 
     def initialize_options(self):
         self.evdev_headers = None
+        self.reproducible = False
 
     def finalize_options(self):
         if self.evdev_headers:
             self.evdev_headers = self.evdev_headers.split(":")
+        if self.reproducible is None:
+            self.reproducible = False
 
     def run(self):
-        create_ecodes(self.evdev_headers)
+        create_ecodes(self.evdev_headers, reproducible=self.reproducible)
 
 
 class build_ext(_build_ext.build_ext):

evdev-1.9.2/src/evdev/__init__.py

@@ -0,0 +1,39 @@
+# --------------------------------------------------------------------------
+# Gather everything into a single, convenient namespace.
+# --------------------------------------------------------------------------
+
+# The superfluous "import name as name" syntax is here to satisfy mypy's attrs-defined rule.
+# Alternatively all exported objects can be listed in __all__.
+
+from . import (
+    ecodes as ecodes,
+    ff as ff,
+)
+
+from .device import (
+    AbsInfo as AbsInfo,
+    DeviceInfo as DeviceInfo,
+    EvdevError as EvdevError,
+    InputDevice as InputDevice,
+)
+
+from .events import (
+    AbsEvent as AbsEvent,
+    InputEvent as InputEvent,
+    KeyEvent as KeyEvent,
+    RelEvent as RelEvent,
+    SynEvent as SynEvent,
+    event_factory as event_factory,
+)
+
+from .uinput import (
+    UInput as UInput,
+    UInputError as UInputError,
+)
+
+from .util import (
+    categorize as categorize,
+    list_devices as list_devices,
+    resolve_ecodes as resolve_ecodes,
+    resolve_ecodes_dict as resolve_ecodes_dict,
+)

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

@@ -1,6 +1,6 @@
 import contextlib
 import os
-from typing import NamedTuple, Tuple, Union
+from typing import Dict, Generic, Iterator, List, Literal, NamedTuple, Tuple, TypeVar, Union, overload
 
 from . import _input, ecodes, util
 
@@ -9,6 +9,8 @@ try:
 except ImportError:
     from .eventio import EvdevError, EventIO
 
+_AnyStr = TypeVar("_AnyStr", str, bytes)
+
 
 class AbsInfo(NamedTuple):
     """Absolute axis information.
@@ -95,19 +97,19 @@ class DeviceInfo(NamedTuple):
     product: int
     version: int
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = "bus: {:04x}, vendor {:04x}, product {:04x}, version {:04x}"
         return msg.format(*self)  # pylint: disable=not-an-iterable
 
 
-class InputDevice(EventIO):
+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[str, bytes, os.PathLike]):
+    def __init__(self, dev: Union[_AnyStr, "os.PathLike[_AnyStr]"]):
         """
         Arguments
         ---------
@@ -116,7 +118,7 @@ class InputDevice(EventIO):
         """
 
         #: Path to input device.
-        self.path = dev if not hasattr(dev, "__fspath__") else dev.__fspath__()
+        self.path: _AnyStr = dev if not hasattr(dev, "__fspath__") else dev.__fspath__()
 
         # Certain operations are possible only when the device is opened in read-write mode.
         try:
@@ -151,7 +153,7 @@ class InputDevice(EventIO):
         #: The number of force feedback effects the device can keep in its memory.
         self.ff_effects_count = _input.ioctl_EVIOCGEFFECTS(self.fd)
 
-    def __del__(self):
+    def __del__(self) -> None:
         if hasattr(self, "fd") and self.fd is not None:
             try:
                 self.close()
@@ -176,7 +178,13 @@ class InputDevice(EventIO):
 
         return res
 
-    def capabilities(self, verbose: bool = False, absinfo: bool = True):
+    @overload
+    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: bool = False, absinfo: bool = True) -> Union[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.
@@ -263,7 +271,7 @@ class InputDevice(EventIO):
 
         return leds
 
-    def set_led(self, led_num: int, value: int):
+    def set_led(self, led_num: int, value: int) -> None:
         """
         Set the state of the selected LED.
 
@@ -279,18 +287,18 @@ class InputDevice(EventIO):
         """
         return isinstance(other, self.__class__) and self.info == other.info and self.path == other.path
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = 'device {}, name "{}", phys "{}", uniq "{}"'
         return msg.format(self.path, self.name, self.phys, self.uniq or "")
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         msg = (self.__class__.__name__, self.path)
         return "{}({!r})".format(*msg)
 
     def __fspath__(self):
         return self.path
 
-    def close(self):
+    def close(self) -> None:
         if self.fd > -1:
             try:
                 super().close()
@@ -298,7 +306,7 @@ class InputDevice(EventIO):
             finally:
                 self.fd = -1
 
-    def grab(self):
+    def grab(self) -> None:
         """
         Grab input device using ``EVIOCGRAB`` - other applications will
         be unable to receive events until the device is released. Only
@@ -311,7 +319,7 @@ class InputDevice(EventIO):
 
         _input.ioctl_EVIOCGRAB(self.fd, 1)
 
-    def ungrab(self):
+    def ungrab(self) -> None:
         """
         Release device if it has been already grabbed (uses `EVIOCGRAB`).
 
@@ -324,7 +332,7 @@ class InputDevice(EventIO):
         _input.ioctl_EVIOCGRAB(self.fd, 0)
 
     @contextlib.contextmanager
-    def grab_context(self):
+    def grab_context(self) -> Iterator[None]:
         """
         A context manager for the duration of which only the current
         process will be able to receive events from the device.
@@ -342,7 +350,7 @@ class InputDevice(EventIO):
         ff_id = _input.upload_effect(self.fd, data)
         return ff_id
 
-    def erase_effect(self, ff_id):
+    def erase_effect(self, ff_id) -> None:
         """
         Erase a force effect from a force feedback device. This also
         stops the effect.
@@ -402,7 +410,7 @@ class InputDevice(EventIO):
         """
         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):
+    def set_absinfo(self, axis_num: int, value=None, min=None, max=None, fuzz=None, flat=None, resolution=None) -> None:
         """
         Update :class:`AbsInfo` values. Only specified values will be overwritten.
 

{evdev-1.9.0 → evdev-1.9.2}/src/evdev/ecodes_runtime.py

@@ -46,7 +46,7 @@ from . import _ecodes
 #: Mapping of names to values.
 ecodes = {}
 
-prefixes = "KEY ABS REL SW MSC LED BTN REP SND ID EV BUS SYN FF_STATUS FF INPUT_PROP".split()
+prefixes = "KEY ABS REL SW MSC LED BTN REP SND ID EV BUS SYN FF_STATUS FF INPUT_PROP UI_FF".split()
 prev_prefix = ""
 g = globals()
 

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

@@ -1,11 +1,57 @@
 import asyncio
 import select
+import sys
 
 from . import eventio
+from .events import InputEvent
 
 # needed for compatibility
 from .eventio import EvdevError
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing import Any as Self
+
+
+class ReadIterator:
+    def __init__(self, device):
+        self.current_batch = iter(())
+        self.device = device
+
+    # Standard iterator protocol.
+    def __iter__(self) -> Self:
+        return self
+
+    def __next__(self) -> InputEvent:
+        try:
+            # Read from the previous batch of events.
+            return next(self.current_batch)
+        except StopIteration:
+            r, w, x = select.select([self.device.fd], [], [])
+            self.current_batch = self.device.read()
+            return next(self.current_batch)
+
+    def __aiter__(self) -> Self:
+        return self
+
+    def __anext__(self) -> "asyncio.Future[InputEvent]":
+        future = asyncio.Future()
+        try:
+            # Read from the previous batch of events.
+            future.set_result(next(self.current_batch))
+        except StopIteration:
+
+            def next_batch_ready(batch):
+                try:
+                    self.current_batch = batch.result()
+                    future.set_result(next(self.current_batch))
+                except Exception as e:
+                    future.set_exception(e)
+
+            self.device.async_read().add_done_callback(next_batch_ready)
+        return future
+
 
 class EventIO(eventio.EventIO):
     def _do_when_readable(self, callback):
@@ -42,7 +88,7 @@ class EventIO(eventio.EventIO):
         self._do_when_readable(lambda: self._set_result(future, self.read))
         return future
 
-    def async_read_loop(self):
+    def async_read_loop(self) -> ReadIterator:
         """
         Return an iterator that yields input events. This iterator is
         compatible with the ``async for`` syntax.
@@ -58,42 +104,3 @@ class EventIO(eventio.EventIO):
             # no event loop present, so there is nothing to
             # remove the reader from. Ignore
             pass
-
-
-class ReadIterator:
-    def __init__(self, device):
-        self.current_batch = iter(())
-        self.device = device
-
-    # Standard iterator protocol.
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        try:
-            # Read from the previous batch of events.
-            return next(self.current_batch)
-        except StopIteration:
-            r, w, x = select.select([self.device.fd], [], [])
-            self.current_batch = self.device.read()
-            return next(self.current_batch)
-
-    def __aiter__(self):
-        return self
-
-    def __anext__(self):
-        future = asyncio.Future()
-        try:
-            # Read from the previous batch of events.
-            future.set_result(next(self.current_batch))
-        except StopIteration:
-
-            def next_batch_ready(batch):
-                try:
-                    self.current_batch = batch.result()
-                    future.set_result(next(self.current_batch))
-                except Exception as e:
-                    future.set_exception(e)
-
-            self.device.async_read().add_done_callback(next_batch_ready)
-        return future

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

@@ -15,22 +15,27 @@ headers = [
     "/usr/include/linux/uinput.h",
 ]
 
-opts, args = getopt.getopt(sys.argv[1:], "", ["ecodes", "stubs"])
+opts, args = getopt.getopt(sys.argv[1:], "", ["ecodes", "stubs", "reproducible"])
 if not opts:
-    print("usage: genecodes.py [--ecodes|--stubs] <headers>")
+    print("usage: genecodes.py [--ecodes|--stubs] [--reproducible] <headers>")
     exit(2)
 
 if args:
     headers = args
 
+reproducible = ("--reproducible", "") in opts
+
 
 # -----------------------------------------------------------------------------
 macro_regex = r"#define\s+((?:KEY|ABS|REL|SW|MSC|LED|BTN|REP|SND|ID|EV|BUS|SYN|FF|UI_FF|INPUT_PROP)_\w+)"
 macro_regex = re.compile(macro_regex)
 
-# Uname without hostname.
-uname = list(os.uname())
-uname = " ".join((uname[0], *uname[2:]))
+if reproducible:
+    uname = "hidden for reproducibility"
+else:
+    # Uname without hostname.
+    uname = list(os.uname())
+    uname = " ".join((uname[0], *uname[2:]))
 
 
 # -----------------------------------------------------------------------------
@@ -138,5 +143,5 @@ elif ("--stubs", "") in opts:
     template = template_stubs
 
 body = os.linesep.join(body)
-text = template % (uname, headers, body)
+text = template % (uname, headers if not reproducible else ["hidden for reproducibility"], body)
 print(text.strip())

{evdev-1.9.0 → evdev-1.9.2}/src/evdev/genecodes_py.py

@@ -40,6 +40,7 @@ entries = [
     ("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)
 ]
@@ -50,4 +51,4 @@ for key, annotation, doc in entries:
 
     print(f"{key}: {annotation} = ", end="")
     pprint(getattr(ecodes, key))
-    print()
+    print()

{evdev-1.9.0 → evdev-1.9.2}/src/evdev/util.py

@@ -6,7 +6,7 @@ import stat
 from typing import Union, List
 
 from . import ecodes
-from .events import event_factory
+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]:
@@ -32,7 +32,7 @@ def is_device(fn: Union[str, bytes, os.PathLike]) -> bool:
     return True
 
 
-def categorize(event):
+def categorize(event: InputEvent) -> Union[InputEvent, KeyEvent, RelEvent, AbsEvent, SynEvent]:
     """
     Categorize an event according to its type.
 

{evdev-1.9.0 → evdev-1.9.2/src/evdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: evdev
-Version: 1.9.0
+Version: 1.9.2
 Summary: Bindings to the Linux input handling subsystem
 Author-email: Georgi Valkov <georgi.t.valkov@gmail.com>
 Maintainer-email: Tobi <proxima@sezanzeb.de>
@@ -46,6 +46,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 # evdev
 

{evdev-1.9.0 → evdev-1.9.2}/tests/test_ecodes.py

@@ -1,9 +1,8 @@
-# encoding: utf-8
-
 from evdev import ecodes
+from evdev import ecodes_runtime
 
 
-prefixes = "KEY ABS REL SW MSC LED BTN REP SND ID EV BUS SYN FF_STATUS FF"
+prefixes = "KEY ABS REL SW MSC LED BTN REP SND ID EV BUS SYN FF_STATUS FF UI_FF"
 
 
 def to_tuples(val):
@@ -29,3 +28,14 @@ def test_overlap():
     vals_ff = set(to_tuples(ecodes.FF.values()))
     vals_ff_status = set(to_tuples(ecodes.FF_STATUS.values()))
     assert bool(vals_ff & vals_ff_status) is False
+
+
+def test_generated():
+    e_run = vars(ecodes_runtime)
+    e_gen = vars(ecodes)
+
+    def keys(v):
+        res = {k for k in v.keys() if not k.startswith("_") and not k[1].islower()}
+        return res
+
+    assert keys(e_run) == keys(e_gen)

evdev-1.9.0/src/evdev/__init__.py

@@ -1,9 +0,0 @@
-# --------------------------------------------------------------------------
-# Gather everything into a single, convenient namespace.
-# --------------------------------------------------------------------------
-
-from . import ecodes, ff
-from .device import AbsInfo, DeviceInfo, EvdevError, InputDevice
-from .events import AbsEvent, InputEvent, KeyEvent, RelEvent, SynEvent, event_factory
-from .uinput import UInput, UInputError
-from .util import categorize, list_devices, resolve_ecodes, resolve_ecodes_dict