evdev-binary 1.9.3__cp314-cp314-musllinux_1_2_x86_64.whl

evdev/uinput.py

@@ -0,0 +1,375 @@
+import ctypes
+import os
+import platform
+import re
+import stat
+import time
+from collections import defaultdict
+from typing import Union, Tuple, Dict, Sequence, Optional
+
+from . import _uinput, ecodes, ff, util
+from .device import InputDevice, AbsInfo
+from .events import InputEvent
+
+try:
+    from evdev.eventio_async import EventIO
+except ImportError:
+    from evdev.eventio import EventIO
+
+
+class UInputError(Exception):
+    pass
+
+
+class UInput(EventIO):
+    """
+    A userland input device and that can inject input events into the
+    linux input subsystem.
+    """
+
+    __slots__ = (
+        "name",
+        "vendor",
+        "product",
+        "version",
+        "bustype",
+        "events",
+        "devnode",
+        "fd",
+        "device",
+    )
+
+    @classmethod
+    def from_device(
+        cls,
+        *devices: Union[InputDevice, Union[str, bytes, os.PathLike]],
+        filtered_types: Tuple[int] = (ecodes.EV_SYN, ecodes.EV_FF),
+        **kwargs,
+    ):
+        """
+        Create an UInput device with the capabilities of one or more input
+        devices.
+
+        Arguments
+        ---------
+        devices : InputDevice|str
+          Varargs of InputDevice instances or paths to input devices.
+
+        filtered_types : Tuple[event type codes]
+          Event types to exclude from the capabilities of the uinput device.
+
+        **kwargs
+          Keyword arguments to UInput constructor (i.e. name, vendor etc.).
+        """
+
+        device_instances = []
+        for dev in devices:
+            if not isinstance(dev, InputDevice):
+                dev = InputDevice(str(dev))
+            device_instances.append(dev)
+
+        all_capabilities = defaultdict(set)
+
+        if "max_effects" not in kwargs:
+            kwargs["max_effects"] = min([dev.ff_effects_count for dev in device_instances])
+
+        # Merge the capabilities of all devices into one dictionary.
+        for dev in device_instances:
+            for ev_type, ev_codes in dev.capabilities().items():
+                all_capabilities[ev_type].update(ev_codes)
+
+        for evtype in filtered_types:
+            if evtype in all_capabilities:
+                del all_capabilities[evtype]
+
+        return cls(events=all_capabilities, **kwargs)
+
+    def __init__(
+        self,
+        events: Optional[Dict[int, Sequence[int]]] = None,
+        name: str = "py-evdev-uinput",
+        vendor: int = 0x1,
+        product: int = 0x1,
+        version: int = 0x1,
+        bustype: int = 0x3,
+        devnode: str = "/dev/uinput",
+        phys: str = "py-evdev-uinput",
+        input_props=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),
+    ):
+        """
+        Arguments
+        ---------
+        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.
+
+        name
+          The name of the input device.
+
+        vendor
+          Vendor identifier.
+
+        product
+          Product identifier.
+
+        version
+          Version identifier.
+
+        bustype
+          Bustype identifier.
+
+        phys
+          Physical path.
+
+        input_props
+          Input properties and quirks.
+
+        max_effects
+          Maximum simultaneous force-feedback effects.
+
+        Note
+        ----
+        If you do not specify any events, the uinput device will be able
+        to inject only ``KEY_*`` and ``BTN_*`` event codes.
+        """
+
+        self.name: str = name  #: Uinput device name.
+        self.vendor: int = vendor  #: Device vendor identifier.
+        self.product: int = product  #: Device product identifier.
+        self.version: int = version  #: Device version identifier.
+        self.bustype: int = bustype  #: Device bustype - e.g. ``BUS_USB``.
+        self.phys: str = phys  #: Uinput device physical path.
+        self.devnode: str = devnode  #: Uinput device node - e.g. ``/dev/uinput/``.
+
+        if not events:
+            events = {ecodes.EV_KEY: ecodes.keys.keys()}
+
+        self._verify()
+
+        #: Write-only, non-blocking file descriptor to the uinput device node.
+        self.fd = _uinput.open(devnode)
+
+        # Prepare the list of events for passing to _uinput.enable and _uinput.setup.
+        absinfo, prepared_events = self._prepare_events(events)
+
+        # Set phys name
+        _uinput.set_phys(self.fd, phys)
+
+        # Set properties
+        input_props = input_props or []
+        for prop in input_props:
+            _uinput.set_prop(self.fd, prop)
+
+        for etype, code in prepared_events:
+            _uinput.enable(self.fd, etype, code)
+
+        _uinput.setup(self.fd, name, vendor, product, version, bustype, absinfo, max_effects)
+
+        # Create the uinput device.
+        _uinput.create(self.fd)
+
+        self.dll = ctypes.CDLL(_uinput.__file__)
+        self.dll._uinput_begin_upload.restype = ctypes.c_int
+        self.dll._uinput_end_upload.restype = ctypes.c_int
+
+        #: An :class:`InputDevice <evdev.device.InputDevice>` instance
+        #: for the fake input device. ``None`` if the device cannot be
+        #: opened for reading and writing.
+        self.device: InputDevice = self._find_device(self.fd)
+
+    def _prepare_events(self, events):
+        """Prepare events for passing to _uinput.enable and _uinput.setup"""
+        absinfo, prepared_events = [], []
+        for etype, codes in events.items():
+            for code in codes:
+                # Handle max, min, fuzz, flat.
+                if isinstance(code, (tuple, list, AbsInfo)):
+                    # Flatten (ABS_Y, (0, 255, 0, 0, 0, 0)) to (ABS_Y, 0, 255, 0, 0, 0, 0).
+                    f = [code[0]]
+                    f.extend(code[1])
+                    # Ensure the tuple is always 6 ints long, since uinput.c:uinput_create
+                    # does little in the way of checking the length.
+                    f.extend([0] * (6 - len(code[1])))
+                    absinfo.append(f)
+                    code = code[0]
+                prepared_events.append((etype, code))
+        return absinfo, prepared_events
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, tb):
+        if hasattr(self, "fd"):
+            self.close()
+
+    def __repr__(self):
+        # 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):
+        msg = 'name "{}", bus "{}", vendor "{:04x}", product "{:04x}", version "{:04x}", phys "{}"\nevent types: {}'
+
+        evtypes = [i[0] for i in self.capabilities(True).keys()]
+        msg = msg.format(
+            self.name, ecodes.BUS[self.bustype], self.vendor, self.product, self.version, self.phys, " ".join(evtypes)
+        )
+
+        return msg
+
+    def close(self):
+        # Close the associated InputDevice, if it was previously opened.
+        if self.device is not None:
+            self.device.close()
+
+        # Destroy the uinput device.
+        if self.fd > -1:
+            _uinput.close(self.fd)
+            self.fd = -1
+
+    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):
+        upload = ff.UInputUpload()
+        upload.effect_id = effect_id
+
+        ret = self.dll._uinput_begin_upload(self.fd, ctypes.byref(upload))
+        if ret:
+            raise UInputError("Failed to begin uinput upload: " + os.strerror(ret))
+
+        return upload
+
+    def end_upload(self, upload):
+        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):
+        erase = ff.UInputErase()
+        erase.effect_id = effect_id
+
+        ret = self.dll._uinput_begin_erase(self.fd, ctypes.byref(erase))
+        if ret:
+            raise UInputError("Failed to begin uinput erase: " + os.strerror(ret))
+        return erase
+
+    def end_erase(self, erase):
+        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):
+        """
+        Verify that an uinput device exists and is readable and writable
+        by the current process.
+        """
+        try:
+            m = os.stat(self.devnode)[stat.ST_MODE]
+            assert stat.S_ISCHR(m)
+        except (IndexError, OSError, AssertionError):
+            msg = '"{}" does not exist or is not a character device file - verify that the uinput module is loaded'
+            raise UInputError(msg.format(self.devnode))
+
+        if not os.access(self.devnode, os.W_OK):
+            msg = '"{}" cannot be opened for writing'
+            raise UInputError(msg.format(self.devnode))
+
+        if len(self.name) > _uinput.maxnamelen:
+            msg = "uinput device name must not be longer than {} characters"
+            raise UInputError(msg.format(_uinput.maxnamelen))
+
+    def _find_device(self, fd: int) -> InputDevice:
+        """
+        Tries to find the device node. Will delegate this task to one of
+        several platform-specific functions.
+        """
+        if platform.system() == "Linux":
+            try:
+                sysname = _uinput.get_sysname(fd)
+                return self._find_device_linux(sysname)
+            except OSError:
+                # UI_GET_SYSNAME returned an error code. We're likely dealing with
+                # an old kernel. Guess the device based on the filesystem.
+                pass
+
+        # If we're not running or Linux or the above method fails for any reason,
+        # use the generic fallback method.
+        return self._find_device_fallback()
+
+    def _find_device_linux(self, sysname: str) -> InputDevice:
+        """
+        Tries to find the device node when running on Linux.
+        """
+
+        syspath = f"/sys/devices/virtual/input/{sysname}"
+
+        # The sysfs entry for event devices should contain exactly one folder
+        # whose name matches the format "event[0-9]+". It is then assumed that
+        # the device node in /dev/input uses the same name.
+        regex = re.compile("event[0-9]+")
+        for entry in os.listdir(syspath):
+            if regex.fullmatch(entry):
+                device_path = f"/dev/input/{entry}"
+                break
+        else:  # no break
+            raise FileNotFoundError()
+
+        # It is possible that there is some delay before /dev/input/event* shows
+        # up on old systems that do not use devtmpfs, so if the device cannot be
+        # found, wait for a short amount and then try again once.
+        #
+        # Furthermore, even if devtmpfs is in use, it is possible that the device
+        # does show up immediately, but without the correct permissions that
+        # still need to be set by udev. Wait for up to two seconds for either the
+        # device to show up or the permissions to be set.
+        for attempt in range(19):
+            try:
+                return InputDevice(device_path)
+            except (FileNotFoundError, PermissionError):
+                time.sleep(0.1)
+
+        # Last attempt. If this fails, whatever exception the last attempt raises
+        # shall be the exception that this function raises.
+        return InputDevice(device_path)
+
+    def _find_device_fallback(self) -> Union[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
+        to interpret its return value.
+        """
+        #:bug: the device node might not be immediately available
+        time.sleep(0.1)
+
+        # There could also be another device with the same name already present,
+        # make sure to select the newest one.
+        # Strictly speaking, we cannot be certain that everything returned by list_devices()
+        # ends at event[0-9]+: it might return something like "/dev/input/events_all". Find
+        # the devices that have the expected structure and extract their device number.
+        path_number_pairs = []
+        regex = re.compile("/dev/input/event([0-9]+)")
+        for path in util.list_devices("/dev/input/"):
+            regex_match = regex.fullmatch(path)
+            if not regex_match:
+                continue
+            device_number = int(regex_match[1])
+            path_number_pairs.append((path, device_number))
+
+        # The modification date of the devnode is not reliable unfortunately, so we
+        # are sorting by the number in the name
+        path_number_pairs.sort(key=lambda pair: pair[1], reverse=True)
+
+        for path, _ in path_number_pairs:
+            d = InputDevice(path)
+            if d.name == self.name:
+                return d

evdev/util.py

@@ -0,0 +1,146 @@
+import collections
+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``."""
+
+    fns = glob.glob("{}/event*".format(input_device_dir))
+    return list(filter(is_device, fns))
+
+
+def is_device(fn: Union[str, bytes, os.PathLike]) -> bool:
+    """Check if ``fn`` is a readable and writable character device."""
+
+    if not os.path.exists(fn):
+        return False
+
+    m = os.stat(fn)[stat.ST_MODE]
+    if not stat.S_ISCHR(m):
+        return False
+
+    if not os.access(fn, os.R_OK | os.W_OK):
+        return False
+
+    return True
+
+
+def categorize(event: InputEvent) -> Union[InputEvent, KeyEvent, RelEvent, AbsEvent, SynEvent]:
+    """
+    Categorize an event according to its type.
+
+    The :data:`event_factory <evdev.events.event_factory>` dictionary
+    maps event types to sub-classes of :class:`InputEvent
+    <evdev.events.InputEvent>`. If the event cannot be categorized, it
+    is returned unmodified."""
+
+    if event.type in event_factory:
+        return event_factory[event.type](event)
+    else:
+        return event
+
+
+def resolve_ecodes_dict(typecodemap, unknown="?"):
+    """
+    Resolve event codes and types to their verbose names.
+
+    :param typecodemap: mapping of event types to lists of event codes.
+    :param unknown: symbol to which unknown types or codes will be resolved.
+
+    Example
+    -------
+    >>> resolve_ecodes_dict({ 1: [272, 273, 274] })
+    { ('EV_KEY', 1): [('BTN_MOUSE',  272),
+                      ('BTN_RIGHT',  273),
+                      ('BTN_MIDDLE', 274)] }
+
+    If ``typecodemap`` contains absolute axis info (instances of
+    :class:`AbsInfo <evdev.device.AbsInfo>` ) the result would look
+    like:
+
+    >>> resolve_ecodes_dict({ 3: [(0, AbsInfo(...))] })
+    { ('EV_ABS', 3L): [(('ABS_X', 0L), AbsInfo(...))] }
+    """
+
+    for etype, codes in typecodemap.items():
+        type_name = ecodes.EV[etype]
+
+        # ecodes.keys are a combination of KEY_ and BTN_ codes
+        if etype == ecodes.EV_KEY:
+            ecode_dict = ecodes.keys
+        else:
+            ecode_dict = getattr(ecodes, type_name.split("_")[-1])
+
+        resolved = resolve_ecodes(ecode_dict, codes, unknown)
+        yield (type_name, etype), resolved
+
+
+def resolve_ecodes(ecode_dict, ecode_list, unknown="?"):
+    """
+    Resolve event codes and types to their verbose names.
+
+    Example
+    -------
+    >>> resolve_ecodes(ecodes.BTN, [272, 273, 274])
+    [(['BTN_LEFT', 'BTN_MOUSE'], 272), ('BTN_RIGHT', 273), ('BTN_MIDDLE', 274)]
+    """
+    res = []
+    for ecode in ecode_list:
+        # elements with AbsInfo(), eg { 3 : [(0, AbsInfo(...)), (1, AbsInfo(...))] }
+        if isinstance(ecode, tuple):
+            if ecode[0] in ecode_dict:
+                l = ((ecode_dict[ecode[0]], ecode[0]), ecode[1])
+            else:
+                l = ((unknown, ecode[0]), ecode[1])
+
+        # just ecodes, e.g: { 0 : [0, 1, 3], 1 : [30, 48] }
+        else:
+            if ecode in ecode_dict:
+                l = (ecode_dict[ecode], ecode)
+            else:
+                l = (unknown, ecode)
+        res.append(l)
+
+    return res
+
+
+def find_ecodes_by_regex(regex):
+    """
+    Find ecodes matching a regex and return a mapping of event type to event codes.
+
+    regex can be a pattern string or a compiled regular expression object.
+
+    Example
+    -------
+    >>> find_ecodes_by_regex(r'(ABS|KEY)_BR(AKE|EAK)')
+    {1: [411], 3: [10]}
+    >>> res = find_ecodes_by_regex(r'(ABS|KEY)_BR(AKE|EAK)')
+    >>> resolve_ecodes_dict(res)
+    {
+        ('EV_KEY', 1): [('KEY_BREAK', 411)],
+        ('EV_ABS', 3): [('ABS_BRAKE', 10)]
+    }
+    """
+
+    regex = re.compile(regex)  # re.compile is idempotent
+    result = collections.defaultdict(list)
+
+    for type_code, codes in ecodes.bytype.items():
+        for code, names in codes.items():
+            names = (names,) if isinstance(names, str) else names
+            for name in names:
+                if regex.match(name):
+                    result[type_code].append(code)
+                    break
+
+    return dict(result)
+
+
+__all__ = ("list_devices", "is_device", "categorize", "resolve_ecodes", "resolve_ecodes_dict", "find_ecodes_by_regex")

evdev_binary-1.9.3.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: evdev-binary
+Version: 1.9.3
+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.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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://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>
+</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.python.org/pypi/evdev
+
+***Changelog:***  
+https://python-evdev.readthedocs.io/en/latest/changelog.html

evdev_binary-1.9.3.dist-info/RECORD

@@ -0,0 +1,24 @@
+evdev/__init__.py,sha256=cu0Qu3CK4loreHKefFqudMmHQP-P-rkXSjrzjxHUCbw,1011
+evdev/_ecodes.cpython-314-x86_64-linux-musl.so,sha256=fINhj1cMccNnQk2fN76xPdB9wh3nNgH1xmn4qpI8Sko,86800
+evdev/_input.cpython-314-x86_64-linux-musl.so,sha256=PqZTiWeavzAIZtuqz_cEu_k7qEmbYK0RTJ7VW-Ugt8s,50232
+evdev/_uinput.cpython-314-x86_64-linux-musl.so,sha256=fGGNoGqLKvAYdxM5v6wCWRcvi9WaQNIJEBMIQoH25ZI,35840
+evdev/device.py,sha256=8sKHGmZh3DF1lJpsIy0pF1R9L5qGzazFGretaysu1Os,12959
+evdev/ecodes.py,sha256=_AVTtsN9w5f4M74FQgbxwAQPOedmCqVts0TCX4AE6Yw,98110
+evdev/ecodes_runtime.py,sha256=_QR3aSjX3pbwrk0f1dA-tXjiECKtV_uPpUtXpWP_cTI,2838
+evdev/eventio.py,sha256=4SnIINjPJadQChUEy_1lbTzuTORsydDC7zL2qkegTIY,4422
+evdev/eventio_async.py,sha256=B1qaEKYoiiop8YpG0AFf0lu2Im3CvW50dRPLug40xWA,3078
+evdev/events.py,sha256=_0vXzjv8yFtJR9drfwhmBZl9w4ZmfwQhgCo3WcrWi-Q,5905
+evdev/evtest.py,sha256=u0umJIV_HQUDlbBhLvXEKZ87UZqNIhk0XJRcm5VYIzg,5543
+evdev/ff.py,sha256=1B1VJ8TJ_CpJ01Qi4tUym1p8qZK_HKQSZvvhA8ROoJY,4961
+evdev/genecodes_c.py,sha256=_AhMK1iOQlkykOSzkbCbCJfZTk_dDU-jLsL_7FhYUqM,3618
+evdev/genecodes_py.py,sha256=-FuU-qy4-C_q7xkSwJICwMbCmAxyvezwSU4L2SRqwAs,1996
+evdev/input.c,sha256=wINgUFPAcFAsjnXaQja3Pr_4h-u4RsX2cEb_IfyvOdk,16346
+evdev/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+evdev/uinput.c,sha256=9CkdJwL57R-qxaBS3T6vCJq9rC2KrRQK7BTHforK4XI,10188
+evdev/uinput.py,sha256=vJb5E0ThptDo6HeB0mc74zFXkh3_oW7a5amn-jhWo9U,13363
+evdev/util.py,sha256=WzgxwgjBuCE25n6UNPk91Bg2_j6weGUv1VO3vfyX8xU,4409
+evdev_binary-1.9.3.dist-info/METADATA,sha256=83J31v0SCp-axino0tX-Nm5UR8CPjqWsIoxLhiIJ46s,1940
+evdev_binary-1.9.3.dist-info/WHEEL,sha256=NmqaxmnfrP7aluxNMb6qEOEbyuTWfFfbybJv9PXNQu4,113
+evdev_binary-1.9.3.dist-info/top_level.txt,sha256=tgRM-peDJTah3Is39Micsqkx31ek4FTHG4usyN23Xsk,6
+evdev_binary-1.9.3.dist-info/RECORD,,
+evdev_binary-1.9.3.dist-info/licenses/LICENSE,sha256=1FVJYNZJYVDIjB_QLXlzEhqaV7lh6lj-NJ-_ito4FrI,1507

evdev_binary-1.9.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: false
+Tag: cp314-cp314-musllinux_1_2_x86_64
+

evdev_binary-1.9.3.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+Copyright (c) 2012-2025 Georgi Valkov. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+
+  3. Neither the name of author nor the names of its contributors may
+     be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

evdev_binary-1.9.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+evdev