evdev-binary 1.9.3__cp314-cp314-musllinux_1_2_x86_64.whl

evdev/evtest.py

@@ -0,0 +1,181 @@
+"""
+Usage: evtest [options] [<device>, ...]
+
+Input device enumerator and event monitor.
+
+Running evtest without any arguments will let you select
+from a list of all readable input devices.
+
+Options:
+  -h, --help          Show this help message and exit.
+  -c, --capabilities  List device capabilities and exit.
+  -g, --grab          Other applications will not receive events from
+                      the selected devices while evtest is running.
+
+Examples:
+  evtest /dev/input/event0 /dev/input/event1
+"""
+
+import atexit
+import optparse
+import re
+import select
+import sys
+import termios
+
+from . import AbsInfo, InputDevice, ecodes, list_devices
+
+
+def parseopt():
+    parser = optparse.OptionParser(add_help_option=False)
+    parser.add_option("-h", "--help", action="store_true")
+    parser.add_option("-g", "--grab", action="store_true")
+    parser.add_option("-c", "--capabilities", action="store_true")
+    return parser.parse_args()
+
+
+def main():
+    opts, devices = parseopt()
+    if opts.help:
+        print(__doc__.strip())
+        return 0
+
+    if not devices:
+        devices = select_devices()
+    else:
+        devices = [InputDevice(path) for path in devices]
+
+    if opts.capabilities:
+        for device in devices:
+            print_capabilities(device)
+        return 0
+
+    if opts.grab:
+        for device in devices:
+            device.grab()
+
+    # Disable tty echoing if stdin is a tty.
+    if sys.stdin.isatty():
+        toggle_tty_echo(sys.stdin, enable=False)
+        atexit.register(toggle_tty_echo, sys.stdin, enable=True)
+
+    print("Listening for events (press ctrl-c to exit) ...")
+    fd_to_device = {dev.fd: dev for dev in devices}
+    while True:
+        r, w, e = select.select(fd_to_device, [], [])
+
+        for fd in r:
+            for event in fd_to_device[fd].read():
+                print_event(event)
+
+
+def select_devices(device_dir="/dev/input"):
+    """
+    Select one or more devices from a list of accessible input devices.
+    """
+
+    def devicenum(device_path):
+        digits = re.findall(r"\d+$", device_path)
+        return [int(i) for i in digits]
+
+    devices = sorted(list_devices(device_dir), key=devicenum)
+    devices = [InputDevice(path) for path in devices]
+    if not devices:
+        msg = "error: no input devices found (do you have rw permission on %s/*?)"
+        print(msg % device_dir, file=sys.stderr)
+        sys.exit(1)
+
+    dev_format = "{0:<3} {1.path:<20} {1.name:<35} {1.phys:<35} {1.uniq:<4}"
+    dev_lines = [dev_format.format(num, dev) for num, dev in enumerate(devices)]
+
+    print("ID  {:<20} {:<35} {:<35} {}".format("Device", "Name", "Phys", "Uniq"))
+    print("-" * len(max(dev_lines, key=len)))
+    print("\n".join(dev_lines))
+    print()
+
+    choices = input("Select devices [0-%s]: " % (len(dev_lines) - 1))
+
+    try:
+        choices = choices.split()
+        choices = [devices[int(num)] for num in choices]
+    except ValueError:
+        choices = None
+
+    if not choices:
+        msg = "error: invalid input - please enter one or more numbers separated by spaces"
+        print(msg, file=sys.stderr)
+        sys.exit(1)
+
+    return choices
+
+
+def print_capabilities(device):
+    capabilities = device.capabilities(verbose=True)
+    input_props = device.input_props(verbose=True)
+
+    print("Device name: {.name}".format(device))
+    print("Device info: {.info}".format(device))
+    print("Repeat settings: {}\n".format(device.repeat))
+
+    if ("EV_LED", ecodes.EV_LED) in capabilities:
+        leds = ",".join(i[0] for i in device.leds(True))
+        print("Active LEDs: %s" % leds)
+
+    active_keys = ",".join(k[0] for k in device.active_keys(True))
+    print("Active keys: %s\n" % active_keys)
+
+    if input_props:
+        print("Input properties:")
+        for type, code in input_props:
+            print("  %s %s" % (type, code))
+        print()
+
+    print("Device capabilities:")
+    for type, codes in capabilities.items():
+        print("  Type {} {}:".format(*type))
+        for code in codes:
+            # code <- ('BTN_RIGHT', 273) or (['BTN_LEFT', 'BTN_MOUSE'], 272)
+            if isinstance(code[1], AbsInfo):
+                print("    Code {:<4} {}:".format(*code[0]))
+                print("      {}".format(code[1]))
+            else:
+                # Multiple names may resolve to one value.
+                s = ", ".join(code[0]) if isinstance(code[0], list) else code[0]
+                print("    Code {:<4} {}".format(s, code[1]))
+        print("")
+
+
+def print_event(e):
+    if e.type == ecodes.EV_SYN:
+        if e.code == ecodes.SYN_MT_REPORT:
+            msg = "time {:<17} +++++++++++++ {} +++++++++++++"
+        elif e.code == ecodes.SYN_DROPPED:
+            msg = "time {:<17} !!!!!!!!!!!!! {} !!!!!!!!!!!!!"
+        else:
+            msg = "time {:<17} ------------- {} -------------"
+        print(msg.format(e.timestamp(), ecodes.SYN[e.code]))
+    else:
+        if e.type in ecodes.bytype:
+            codename = ecodes.bytype[e.type][e.code]
+        else:
+            codename = "?"
+
+        evfmt = "time {:<17} type {} ({}), code {:<4} ({}), value {}"
+        print(evfmt.format(e.timestamp(), e.type, ecodes.EV[e.type], e.code, codename, e.value))
+
+
+def toggle_tty_echo(fh, enable=True):
+    flags = termios.tcgetattr(fh.fileno())
+    if enable:
+        flags[3] |= termios.ECHO
+    else:
+        flags[3] &= ~termios.ECHO
+    termios.tcsetattr(fh.fileno(), termios.TCSANOW, flags)
+
+
+if __name__ == "__main__":
+    try:
+        ret = main()
+    except (KeyboardInterrupt, EOFError):
+        ret = 0
+    sys.exit(ret)

evdev/ff.py

@@ -0,0 +1,198 @@
+import ctypes
+
+from . import ecodes
+
+_u8 = ctypes.c_uint8
+_u16 = ctypes.c_uint16
+_u32 = ctypes.c_uint32
+_s16 = ctypes.c_int16
+_s32 = ctypes.c_int32
+
+
+class Replay(ctypes.Structure):
+    """
+    Defines scheduling of the force-feedback effect
+    @length: duration of the effect
+    @delay: delay before effect should start playing
+    """
+
+    _fields_ = [
+        ("length", _u16),
+        ("delay", _u16),
+    ]
+
+
+class Trigger(ctypes.Structure):
+    """
+    Defines what triggers the force-feedback effect
+    @button: number of the button triggering the effect
+    @interval: controls how soon the effect can be re-triggered
+    """
+
+    _fields_ = [
+        ("button", _u16),
+        ("interval", _u16),
+    ]
+
+
+class Envelope(ctypes.Structure):
+    """
+    Generic force-feedback effect envelope
+    @attack_length: duration of the attack (ms)
+    @attack_level: level at the beginning of the attack
+    @fade_length: duration of fade (ms)
+    @fade_level: level at the end of fade
+
+    The @attack_level and @fade_level are absolute values; when applying
+    envelope force-feedback core will convert to positive/negative
+    value based on polarity of the default level of the effect.
+    Valid range for the attack and fade levels is 0x0000 - 0x7fff
+    """
+
+    _fields_ = [
+        ("attack_length", _u16),
+        ("attack_level", _u16),
+        ("fade_length", _u16),
+        ("fade_level", _u16),
+    ]
+
+
+class Constant(ctypes.Structure):
+    """
+    Defines parameters of a constant force-feedback effect
+    @level: strength of the effect; may be negative
+    @envelope: envelope data
+    """
+
+    _fields_ = [
+        ("level", _s16),
+        ("ff_envelope", Envelope),
+    ]
+
+
+class Ramp(ctypes.Structure):
+    """
+    Defines parameters of a ramp force-feedback effect
+    @start_level: beginning strength of the effect; may be negative
+    @end_level: final strength of the effect; may be negative
+    @envelope: envelope data
+    """
+
+    _fields_ = [
+        ("start_level", _s16),
+        ("end_level", _s16),
+        ("ff_envelope", Envelope),
+    ]
+
+
+class Condition(ctypes.Structure):
+    """
+    Defines a spring or friction force-feedback effect
+    @right_saturation: maximum level when joystick moved all way to the right
+    @left_saturation: same for the left side
+    @right_coeff: controls how fast the force grows when the joystick moves to the right
+    @left_coeff: same for the left side
+    @deadband: size of the dead zone, where no force is produced
+    @center: position of the dead zone
+    """
+
+    _fields_ = [
+        ("right_saturation", _u16),
+        ("left_saturation", _u16),
+        ("right_coeff", _s16),
+        ("left_coeff", _s16),
+        ("deadband", _u16),
+        ("center", _s16),
+    ]
+
+
+class Periodic(ctypes.Structure):
+    """
+    Defines parameters of a periodic force-feedback effect
+    @waveform: kind of the effect (wave)
+    @period: period of the wave (ms)
+    @magnitude: peak value
+    @offset: mean value of the wave (roughly)
+    @phase: 'horizontal' shift
+    @envelope: envelope data
+    @custom_len: number of samples (FF_CUSTOM only)
+    @custom_data: buffer of samples (FF_CUSTOM only)
+    """
+
+    _fields_ = [
+        ("waveform", _u16),
+        ("period", _u16),
+        ("magnitude", _s16),
+        ("offset", _s16),
+        ("phase", _u16),
+        ("envelope", Envelope),
+        ("custom_len", _u32),
+        ("custom_data", ctypes.POINTER(_s16)),
+    ]
+
+
+class Rumble(ctypes.Structure):
+    """
+    Defines parameters of a periodic force-feedback effect
+    @strong_magnitude: magnitude of the heavy motor
+    @weak_magnitude: magnitude of the light one
+
+    Some rumble pads have two motors of different weight. Strong_magnitude
+    represents the magnitude of the vibration generated by the heavy one.
+    """
+
+    _fields_ = [
+        ("strong_magnitude", _u16),
+        ("weak_magnitude", _u16),
+    ]
+
+
+class EffectType(ctypes.Union):
+    _fields_ = [
+        ("ff_constant_effect", Constant),
+        ("ff_ramp_effect", Ramp),
+        ("ff_periodic_effect", Periodic),
+        ("ff_condition_effect", Condition * 2),  # one for each axis
+        ("ff_rumble_effect", Rumble),
+    ]
+
+
+class Effect(ctypes.Structure):
+    _fields_ = [
+        ("type", _u16),
+        ("id", _s16),
+        ("direction", _u16),
+        ("ff_trigger", Trigger),
+        ("ff_replay", Replay),
+        ("u", EffectType),
+    ]
+
+
+class UInputUpload(ctypes.Structure):
+    _fields_ = [
+        ("request_id", _u32),
+        ("retval", _s32),
+        ("effect", Effect),
+        ("old", Effect),
+    ]
+
+
+class UInputErase(ctypes.Structure):
+    _fields_ = [
+        ("request_id", _u32),
+        ("retval", _s32),
+        ("effect_id", _u32),
+    ]
+
+
+# ff_types = {
+#     ecodes.FF_CONSTANT,
+#     ecodes.FF_PERIODIC,
+#     ecodes.FF_RAMP,
+#     ecodes.FF_SPRING,
+#     ecodes.FF_FRICTION,
+#     ecodes.FF_DAMPER,
+#     ecodes.FF_RUMBLE,
+#     ecodes.FF_INERTIA,
+#     ecodes.FF_CUSTOM,
+# }

evdev/genecodes_c.py

@@ -0,0 +1,147 @@
+"""
+Generate a Python extension module with the constants defined in linux/input.h.
+"""
+
+import getopt
+import os
+import re
+import sys
+
+# -----------------------------------------------------------------------------
+# The default header file locations to try.
+headers = [
+    "/usr/include/linux/input.h",
+    "/usr/include/linux/input-event-codes.h",
+    "/usr/include/linux/uinput.h",
+]
+
+opts, args = getopt.getopt(sys.argv[1:], "", ["ecodes", "stubs", "reproducible"])
+if not opts:
+    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)
+
+if reproducible:
+    uname = "hidden for reproducibility"
+else:
+    # Uname without hostname.
+    uname = list(os.uname())
+    uname = " ".join((uname[0], *uname[2:]))
+
+
+# -----------------------------------------------------------------------------
+template_ecodes = r"""
+#include <Python.h>
+#ifdef __FreeBSD__
+#include <dev/evdev/input.h>
+#include <dev/evdev/uinput.h>
+#else
+#include <linux/input.h>
+#include <linux/uinput.h>
+#endif
+
+/* Automatically generated by evdev.genecodes */
+/* Generated on   %s */
+/* Generated from %s */
+
+#define MODULE_NAME "_ecodes"
+#define MODULE_HELP "linux/input.h macros"
+
+static PyMethodDef MethodTable[] = {
+    { NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    MODULE_NAME,
+    MODULE_HELP,
+    -1,          /* m_size */
+    MethodTable, /* m_methods */
+    NULL,        /* m_reload */
+    NULL,        /* m_traverse */
+    NULL,        /* m_clear */
+    NULL,        /* m_free */
+};
+
+PyMODINIT_FUNC
+PyInit__ecodes(void)
+{
+    PyObject* m = PyModule_Create(&moduledef);
+    if (m == NULL) return NULL;
+
+%s
+
+    return m;
+}
+"""
+
+
+template_stubs = r"""
+# Automatically generated by evdev.genecodes
+# Generated on %s
+# Generated from %s
+
+# pylint: skip-file
+
+ecodes: dict[str, int]
+keys: dict[int, str|list[str]]
+bytype: dict[int, dict[int, str|list[str]]]
+
+KEY: dict[int, str|list[str]]
+ABS: dict[int, str|list[str]]
+REL: dict[int, str|list[str]]
+SW:  dict[int, str|list[str]]
+MSC: dict[int, str|list[str]]
+LED: dict[int, str|list[str]]
+BTN: dict[int, str|list[str]]
+REP: dict[int, str|list[str]]
+SND: dict[int, str|list[str]]
+ID:  dict[int, str|list[str]]
+EV:  dict[int, str|list[str]]
+BUS: dict[int, str|list[str]]
+SYN: dict[int, str|list[str]]
+FF_STATUS:     dict[int, str|list[str]]
+FF_INPUT_PROP: dict[int, str|list[str]]
+
+%s
+"""
+
+
+def parse_headers(headers=headers):
+    for header in headers:
+        try:
+            fh = open(header)
+        except (IOError, OSError):
+            continue
+
+        for line in fh:
+            macro = macro_regex.search(line)
+            if macro:
+                yield macro.group(1)
+
+
+all_macros = list(parse_headers())
+if not all_macros:
+    print("no input macros found in: %s" % " ".join(headers), file=sys.stderr)
+    sys.exit(1)
+
+# pylint: disable=possibly-used-before-assignment, used-before-assignment
+if ("--ecodes", "") in opts:
+    body = ("    PyModule_AddIntMacro(m, %s);" % macro for macro in all_macros)
+    template = template_ecodes
+elif ("--stubs", "") in opts:
+    body = ("%s: int" % macro for macro in all_macros)
+    template = template_stubs
+
+body = os.linesep.join(body)
+text = template % (uname, headers if not reproducible else ["hidden for reproducibility"], body)
+print(text.strip())

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, 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()