JezK
Edit File: _clib.py
# -*- coding: latin-1 -*- # Copyright © 2016 Red Hat, Inc. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice (including the next # paragraph) shall be included in all copies or substantial portions of the # Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. import libevdev import os import ctypes import errno from ctypes import c_char_p from ctypes import c_int from ctypes import c_uint from ctypes import c_void_p from ctypes import c_long from ctypes import c_int32 from ctypes import c_uint16 READ_FLAG_SYNC = 0x1 READ_FLAG_NORMAL = 0x2 READ_FLAG_FORCE_SYNC = 0x4 READ_FLAG_BLOCKING = 0x8 class _InputAbsinfo(ctypes.Structure): _fields_ = [("value", c_int32), ("minimum", c_int32), ("maximum", c_int32), ("fuzz", c_int32), ("flat", c_int32), ("resolution", c_int32)] class _InputEvent(ctypes.Structure): _fields_ = [("sec", c_long), ("usec", c_long), ("type", c_uint16), ("code", c_uint16), ("value", c_int32)] class _LibraryWrapper(object): """ Base class for wrapping a shared library. Do not use directly. """ _lib = None # The shared library, shared between instances of the class # List of API prototypes, must be set by the subclass _api_prototypes = { # "function_name" : { # "argtypes": [c_void_p, c_char_p, etc. ], # arguments # "restype": c_void_p, # return type # "restype": c_void_p, # return type # } } def __init__(self): super(_LibraryWrapper, self).__init__() self._load() @classmethod def _load(cls): if cls._lib is not None: return cls._lib cls._lib = cls._cdll() for (name, attrs) in cls._api_prototypes.items(): func = getattr(cls._lib, name) func.argtypes = attrs["argtypes"] func.restype = attrs["restype"] # default name is the libevdev name minus the libevdev prefix # This makes all functions hidden and require # one-by-one-mapping prefix = len("libevdev") pyname = dict.get(attrs, "name", name[prefix:]) setattr(cls, pyname, func) return cls._lib @staticmethod def _cdll(): """Override in subclass""" raise NotImplementedError class Libevdev(_LibraryWrapper): """ This class provides a wrapper around the libevdev C library. The API is modelled closely after the C API. API documentation in this document only lists the specific behavior of the Phython API. For information on the behavior of libevdev itself, see https://www.freedesktop.org/software/libevdev/doc/latest/ Properties in this class are read-write unless specified otherwise. .. warning:: Do not use this class directly """ @staticmethod def _cdll(): return ctypes.CDLL("libevdev.so.2", use_errno=True) _api_prototypes = { # const char *libevdev_event_type_get_name(unsigned int type); "libevdev_event_type_get_name": { "argtypes": (c_uint,), "restype": c_char_p }, # int libevdev_event_type_from_name(const char *name); "libevdev_event_type_from_name": { "argtypes": (c_char_p,), "restype": c_int }, # const char *libevdev_event_code_get_name(unsigned int type, unsigned int code); "libevdev_event_code_get_name": { "argtypes": (c_uint, c_uint,), "restype": c_char_p }, # int libevdev_event_code_from_name(unsigned int type, const char *name); "libevdev_event_code_from_name": { "argtypes": (c_uint, c_char_p,), "restype": c_int }, # const char *libevdev_property_get_name(unsigned int prop); "libevdev_property_get_name": { "argtypes": (c_uint,), "restype": c_char_p, }, # int libevdev_property_from_name(const char *name); "libevdev_property_from_name": { "argtypes": (c_char_p,), "restype": c_int }, # void libevdev_event_type_get_max(int) "libevdev_event_type_get_max": { "argtypes": (c_int, ), "restype": c_int, }, # struct libevdev *libevdev_new(void); "libevdev_new": { "argtypes": (), "restype": c_void_p, }, # struct libevdev *libevdev_free(struct libevdev *); "libevdev_free": { "argtypes": (c_void_p,), "restype": None, }, ############################### # Simple getters and setters # ############################### # const char * libevdev_get_name(struct libevdev *); "libevdev_get_name": { "argtypes": (c_void_p,), "restype": c_char_p, }, # void libevdev_set_name(struct libevdev *, const char*); "libevdev_set_name": { "argtypes": (c_void_p, c_char_p), "restype": None, }, # const char * libevdev_get_phys(struct libevdev *); "libevdev_get_phys": { "argtypes": (c_void_p,), "restype": c_char_p, }, # void libevdev_set_phys(struct libevdev *, const char*); "libevdev_set_phys": { "argtypes": (c_void_p, c_char_p), "restype": None, }, # const char * libevdev_get_uniq(struct libevdev *); "libevdev_get_uniq": { "argtypes": (c_void_p,), "restype": c_char_p, }, # void libevdev_set_uniq(struct libevdev *, const char*); "libevdev_set_uniq": { "argtypes": (c_void_p, c_char_p), "restype": None, }, # int libevdev_get_driver_version(struct libevdev *); "libevdev_get_driver_version": { "argtypes": (c_void_p, ), "restype": c_int, }, # void libevdev_set_clock_id(struct libevdev *, int) "libevdev_set_clock_id": { "argtypes": (c_void_p, c_int), "restype": c_int, }, ############################### # Custom getters and setters # ############################### # int libevdev_get_id_bustype(struct libevdev *) "libevdev_get_id_bustype": { "argtypes": (c_void_p,), "restype": c_int, }, # int libevdev_get_id_vendor(struct libevdev *) "libevdev_get_id_vendor": { "argtypes": (c_void_p,), "restype": c_int, }, # int libevdev_get_id_product(struct libevdev *) "libevdev_get_id_product": { "argtypes": (c_void_p,), "restype": c_int, }, # int libevdev_get_id_version(struct libevdev *) "libevdev_get_id_version": { "argtypes": (c_void_p,), "restype": c_int, }, # void libevdev_set_id_bustype(struct libevdev *, int) "libevdev_set_id_bustype": { "argtypes": (c_void_p, c_int), "restype": None, }, # void libevdev_set_id_vendor(struct libevdev *, int) "libevdev_set_id_vendor": { "argtypes": (c_void_p, c_int), "restype": None, }, # void libevdev_set_id_product(struct libevdev *, int) "libevdev_set_id_product": { "argtypes": (c_void_p, c_int), "restype": None, }, # void libevdev_set_id_version(struct libevdev *, int) "libevdev_set_id_version": { "argtypes": (c_void_p, c_int), "restype": None, }, # int libevdev_set_fd(struct libevdev *, int) "libevdev_set_fd": { "argtypes": (c_void_p, c_int), "restype": c_int, }, # int libevdev_change_fd(struct libevdev *, int) "libevdev_change_fd": { "argtypes": (c_void_p, c_int), "restype": c_int, }, # int libevdev_get_fd(struct libevdev *) "libevdev_get_fd": { "argtypes": (c_void_p, ), "restype": c_int, }, # int libevdev_grab(struct libevdev *) "libevdev_grab": { "argtypes": (c_void_p, c_int), "restype": c_int, }, # const struct input_absinfo *libevdev_get_abs_info(struct libevdev*, int code) "libevdev_get_abs_info": { "argtypes": (c_void_p, c_int), "restype": ctypes.POINTER(_InputAbsinfo), }, # We don't need to wrap libevdev_set_abs_info(), we get the same # using get_abs_info and overwrite the values. # # const struct input_absinfo *libevdev_get_abs_info(struct libevdev*, int code) "libevdev_kernel_set_abs_info": { "argtypes": (c_void_p, c_int, ctypes.POINTER(_InputAbsinfo)), "restype": (c_int) }, ########################## # Various has_ functions # ########################## "libevdev_has_property": { "argtypes": (c_void_p, c_int), "restype": (c_int) }, "libevdev_has_event_type": { "argtypes": (c_void_p, c_int), "restype": (c_int) }, "libevdev_has_event_code": { "argtypes": (c_void_p, c_int, c_int), "restype": (c_int) }, ########################## # Other functions # ########################## "libevdev_set_event_value": { "argtypes": (c_void_p, c_int, c_int, c_int), "restype": (c_int) }, "libevdev_get_event_value": { "argtypes": (c_void_p, c_int, c_int), "restype": (c_int), }, "libevdev_enable_event_type": { "argtypes": (c_void_p, c_int), "restype": (c_int), }, "libevdev_enable_event_code": { "argtypes": (c_void_p, c_int, c_int, c_void_p), "restype": (c_int), }, "libevdev_disable_event_type": { "argtypes": (c_void_p, c_int), "restype": (c_int), }, "libevdev_disable_event_code": { "argtypes": (c_void_p, c_int, c_int), "restype": (c_int), }, "libevdev_enable_property": { "argtypes": (c_void_p, c_int), "restype": (c_int), }, "libevdev_next_event": { "argtypes": (c_void_p, c_uint, ctypes.POINTER(_InputEvent)), "restype": c_int, }, "libevdev_get_num_slots": { "argtypes": (c_void_p,), "restype": c_int, }, "libevdev_get_current_slot": { "argtypes": (c_void_p,), "restype": c_int, }, "libevdev_get_slot_value": { "argtypes": (c_void_p, c_uint, c_uint), "restype": c_int, }, "libevdev_set_slot_value": { "argtypes": (c_void_p, c_uint, c_uint, c_int), "restype": c_int, }, "libevdev_has_event_pending": { "argtypes": (c_void_p,), "restype": c_int, }, } def __init__(self, fd=None): """ :param fd: A file-like object Create a new libevdev instance. If a file is given this call is equivalent to ``libevdev_new_from_fd()``, otherwise it is equivalent to ``libevdev_new()``:: fd = open("/dev/input/event0", "rb") l = libevdev.Libevdev(fd) # l now represents the device on event0 l2 = libevdev.Libevdev() l2.name = "test device" l2.enable("EV_REL", "REL_X") # l2 is an unbound device with the REL_X bit set """ super(Libevdev, self).__init__() self._ctx = self._new() self._file = None if fd is not None: self.fd = fd def __del__(self): if hasattr(self, "_ctx"): self._free(self._ctx) @property def name(self): """ :return: A string with the device's kernel name. """ return self._get_name(self._ctx).decode("iso8859-1") @name.setter def name(self, name): if name is None: name = '' return self._set_name(self._ctx, name.encode("iso8859-1")) @property def phys(self): """ :return: A string with the device's kernel phys or None. """ phys = self._get_phys(self._ctx) if not phys: return None return phys.decode("iso8859-1") @phys.setter def phys(self, phys): # libevdev issue: phys may be NULL, but can't be set to NULL if phys is None: phys = '' return self._set_phys(self._ctx, phys.encode("iso8859-1")) @property def uniq(self): """ :return: A string with the device's kernel uniq or None. """ uniq = self._get_uniq(self._ctx) if not uniq: return None return uniq.decode("iso8859-1") @uniq.setter def uniq(self, uniq): # libevdev issue: uniq may be NULL, but can't be set to NULL if uniq is None: uniq = '' return self._set_uniq(self._ctx, uniq.encode("iso8859-1")) @property def driver_version(self): """ :note: Read-only """ return self._get_driver_version(self._ctx) @property def id(self): """ :return: A dict with the keys 'bustype', 'vendor', 'product', 'version'. When used as a setter, only existing keys are applied to the device. For example, to update the product ID only:: ctx = Libevdev() id["property"] = 1234 ctx.id = id This is a combined version of the libevdev calls ``libevdev_get_id_busytype()``, ``libevdev_get_id_vendor()``, ``libevdev_get_id_product()``, ``libevdev_get_id_version()`` and the respective setters. """ bus = self._get_id_bustype(self._ctx) vdr = self._get_id_vendor(self._ctx) pro = self._get_id_product(self._ctx) ver = self._get_id_version(self._ctx) return {"bustype": bus, "vendor": vdr, "product": pro, "version": ver} @id.setter def id(self, vals): if "bustype" in vals: self._set_id_bustype(self._ctx, vals["bustype"]) if "vendor" in vals: self._set_id_vendor(self._ctx, vals["vendor"]) if "product" in vals: self._set_id_product(self._ctx, vals["product"]) if "version" in vals: self._set_id_version(self._ctx, vals["version"]) def set_clock_id(self, clock): """ :param clock: time.CLOCK_MONOTONIC :return: a negative errno on failure or 0 on success. """ return self._set_clock_id(self._ctx, clock) @property def fd(self): """ :return: The file-like object used during constructor or in the most recent assignment to self.fd. When assigned the first time and no file has been passed to the constructor, the assignment is equivalent to ``libevdev_set_fd()``. Subsequently, any assignments are equivalent to ``libevdev_change_fd``:: fd = open("/dev/input/event0", "rb") l = libevdev.Libevdev(fd) assert(l.fd == fd) fd2 = open("/dev/input/event0", "rb") l.fd = fd2 assert(l.fd == fd2) l = libevdev.Libevdev() l.fd = fd assert(l.fd == fd) l.fd = fd2 assert(l.fd == fd2) :note: libevdev uses the ``fileno()`` of the object. """ return self._file @fd.setter def fd(self, fileobj): try: fd = fileobj.fileno() except AttributeError: raise libevdev.InvalidFileError if self._file is None: r = self._set_fd(self._ctx, fd) else: r = self._change_fd(self._ctx, fd) if r != 0: raise OSError(-r, os.strerror(-r)) # sanity check: if self._get_fd(self._ctx) != fd: print("FIXME: fileno() != get_fd()") self._file = fileobj def grab(self, enable_grab=True): """ :param enable_grab: True to grab, False to ungrab :return: 0 on success or a negative errno on failure """ # libevdev doesn't use 0/1 here but numbered values if enable_grab: mode = 3 else: mode = 4 r = self._grab(self._ctx, mode) if r != 0: raise OSError(-r, os.strerror(-r)) def absinfo(self, code, new_values=None, kernel=False): """ :param code: the ABS_<*> code as integer or as string :param new_values: a dict with the same keys as the return values. :param kernel: If True, assigning new values corresponds to ``libevdev_kernel_set_abs_info`` :return: a dictionary with the keys "value", "min", "max", "resolution", "fuzz", "flat"; ``None`` if the code does not exist on this device :note: The returned value is a copy of the value returned by libevdev. Changing a value in the dictionary does not change the matching property. To change the device, reassign the dictionary to the absinfo code. This is different to the libevdev behavior. """ if not isinstance(code, int): if not code.startswith("ABS_"): raise ValueError() code = self.event_to_value("EV_ABS", code) absinfo = self._get_abs_info(self._ctx, code) if not absinfo: return None if new_values is not None: if "minimum" in new_values: absinfo.contents.minimum = new_values["minimum"] if "maximum" in new_values: absinfo.contents.maximum = new_values["maximum"] if "value" in new_values: absinfo.contents.value = new_values["value"] if "fuzz" in new_values: absinfo.contents.fuzz = new_values["fuzz"] if "flat" in new_values: absinfo.contents.flat = new_values["flat"] if "resolution" in new_values: absinfo.contents.resolution = new_values["resolution"] if kernel: rc = self._kernel_set_abs_info(self._ctx, code, absinfo) if rc != 0: raise OSError(-rc, os.strerror(-rc)) return {"value": absinfo.contents.value, "minimum": absinfo.contents.minimum, "maximum": absinfo.contents.maximum, "fuzz": absinfo.contents.fuzz, "flat": absinfo.contents.flat, "resolution": absinfo.contents.resolution} @classmethod def property_to_name(cls, prop): """ :param prop: the numerical property value :return: A string with the property name or ``None`` This function is the equivalent to ``libevdev_property_get_name()`` """ name = cls._property_get_name(prop) if not name: return None return name.decode("iso8859-1") @classmethod def property_to_value(cls, prop): """ :param prop: the property name as string :return: The numerical property value or ``None`` This function is the equivalent to ``libevdev_property_from_name()`` """ v = cls._property_from_name(prop.encode("iso8859-1")) if v == -1: return None return v @classmethod def type_max(cls, type): """ :param type: the EV_<*> event type :return: the maximum code for this type or ``None`` if the type is invalid """ if not isinstance(type, int): type = cls.event_to_value(type) m = cls._event_type_get_max(type) return m if m > -1 else None @classmethod def event_to_name(cls, event_type, event_code=None): """ :param event_type: the numerical event type value :param event_code: optional, the numerical event code value :return: the event code name if a code is given otherwise the event type name. This function is the equivalent to ``libevdev_event_code_get_name()`` and ``libevdev_event_type_get_name()`` """ if event_code is not None: name = cls._event_code_get_name(event_type, event_code) else: name = cls._event_type_get_name(event_type) if not name: return None return name.decode("iso8859-1") @classmethod def event_to_value(cls, event_type, event_code=None): """ :param event_type: the event type as string :param event_code: optional, the event code as string :return: the event code value if a code is given otherwise the event type value. This function is the equivalent to ``libevdev_event_code_from_name()`` and ``libevdev_event_type_from_name()`` """ if event_code is not None: if not isinstance(event_type, int): event_type = cls.event_to_value(event_type) v = cls._event_code_from_name(event_type, event_code.encode("iso8859-1")) else: v = cls._event_type_from_name(event_type.encode("iso8859-1")) if v == -1: return None return v def has_property(self, prop): """ :param prop: a property, either as integer or string :return: True if the device has the property, False otherwise """ if not isinstance(prop, int): prop = self.property_to_value(prop) r = self._has_property(self._ctx, prop) return bool(r) def has_event(self, event_type, event_code=None): """ :param event_type: the event type, either as integer or as string :param event_code: optional, the event code, either as integer or as string :return: True if the device has the type and/or code, False otherwise """ if not isinstance(event_type, int): event_type = self.event_to_value(event_type) if event_code is None: r = self._has_event_type(self._ctx, event_type) else: if not isinstance(event_code, int): event_code = self.event_to_value(event_type, event_code) r = self._has_event_code(self._ctx, event_type, event_code) return bool(r) def _code(self, t, c): """ Resolves a type+code tuple, either of which could be integer or string. Returns a (t, c) tuple in integers """ if not isinstance(t, int): t = self.event_to_value(t) if c is not None and not isinstance(c, int): c = self.event_to_value(t, c) return (t, c) def event_value(self, event_type, event_code, new_value=None): """ :param event_type: the event type, either as integer or as string :param event_code: the event code, either as integer or as string :param new_value: optional, the value to set to :return: the current value of type + code, or ``None`` if it doesn't exist on this device """ t, c = self._code(event_type, event_code) if not self.has_event(t, c): return None if new_value is not None: self._set_event_value(self._ctx, t, c, new_value) v = self._get_event_value(self._ctx, t, c) return v @property def num_slots(self): """ :return: the number of slots on this device or ``None`` if this device does not support slots :note: Read-only """ s = self._get_num_slots(self._ctx) return s if s >= 0 else None @property def current_slot(self): """ :return: the current of slots on this device or ``None`` if this device does not support slots :note: Read-only """ s = self._get_current_slot(self._ctx) return s if s >= 0 else None def slot_value(self, slot, event_code, new_value=None): """ :param slot: the numeric slot number :param event_code: the ABS_<*> event code, either as integer or string :param new_value: optional, the value to set this slot to :return: the current value of the slot's code, or ``None`` if it doesn't exist on this device """ t, c = self._code("EV_ABS", event_code) if new_value is not None: self._set_slot_value(self._ctx, slot, c, new_value) v = self._get_slot_value(self._ctx, slot, c) return v def enable(self, event_type, event_code=None, data=None): """ :param event_type: the event type, either as integer or as string :param event_code: optional, the event code, either as integer or as string :param data: if event_code is not ``None``, data points to the code-specific information. If event_type is EV_ABS, then data must be a dictionary as returned from absinfo. Any keys missing are replaced with 0, i.e. the following example is valid and results in a fuzz/flat/resolution of zero:: ctx = Libevdev() abs = { "minimum" : 0, "maximum" : 100 } ctx.enable("EV_ABS", "ABS_X", data) If event_type is EV_REP, then data must be an integer. """ t, c = self._code(event_type, event_code) if c is None: self._enable_event_type(self._ctx, t) else: if t == 0x03: # EV_ABS data = _InputAbsinfo(data.get("value", 0), data.get("minimum", 0), data.get("maximum", 0), data.get("fuzz", 0), data.get("flat", 0), data.get("resolution", 0)) data = ctypes.pointer(data) elif t == 0x14: # EV_REP data = ctypes.pointer(c_int(data)) self._enable_event_code(self._ctx, t, c, data) def disable(self, event_type, event_code=None): """ :param event_type: the event type, either as integer or as string :param event_code: optional, the event code, either as integer or as string """ t, c = self._code(event_type, event_code) if c is None: self._disable_event_type(self._ctx, t) else: self._disable_event_code(self._ctx, t, c) def enable_property(self, prop): """ :param prop: the property as integer or string """ if not isinstance(prop, int): prop = self.property_to_value(prop) self._enable_property(self._ctx, prop) def set_led(self, led, on): """ :param led: the LED_<*> name :on: True to turn the LED on, False to turn it off """ t, c = self._code("EV_LED", led) which = 3 if on else 4 self._set_led_value(self._ctx, c, which) def next_event(self, flags=READ_FLAG_NORMAL): """ :param flags: a set of libevdev read flags. May be omitted to use the normal mode. :return: the next event or ``None`` if no event is available Event processing should look like this:: fd = open("/dev/input/event0", "rb") ctx = libevdev.Libevdev(fd) ev = ctx.next_event() if ev is None: print("no event available right now") elif ev.matches("EV_SYN", "SYN_DROPPED"): sync_ev = ctx.next_event(libevdev.READ_FLAG_SYNC) while ev is not None: print("First event in sync sequence") sync_ev = ctx.next_event(libevdev.READ_FLAG_SYNC) print("sync complete") """ ev = _InputEvent() rc = self._next_event(self._ctx, flags, ctypes.byref(ev)) if rc == -errno.EAGAIN: return None return ev class _UinputDevice(ctypes.Structure): pass class UinputDevice(_LibraryWrapper): """ This class provides a wrapper around the libevdev C library .. warning:: Do not use this class directly """ @staticmethod def _cdll(): return ctypes.CDLL("libevdev.so.2", use_errno=True) _api_prototypes = { # int libevdev_uinput_create_from_device(const struct libevdev *, int, struct libevdev_uinput **) "libevdev_uinput_create_from_device": { "argtypes": (c_void_p, c_int, ctypes.POINTER(ctypes.POINTER(_UinputDevice))), "restype": c_int }, # int libevdev_uinput_destroy(const struct libevdev *) "libevdev_uinput_destroy": { "argtypes": (c_void_p,), "restype": None, }, # const char* libevdev_uinput_get_devnode(const struct libevdev *) "libevdev_uinput_get_devnode": { "argtypes": (c_void_p,), "restype": c_char_p, }, # const char* libevdev_uinput_get_syspath(const struct libevdev *) "libevdev_uinput_get_syspath": { "argtypes": (c_void_p,), "restype": c_char_p, }, # int libevdev_uinput_write_event(const struct libevdev *, uint, uint, int) "libevdev_uinput_write_event": { "argtypes": (c_void_p, c_uint, c_uint, c_int), "restype": c_int }, } def __init__(self, source, fileobj=None): """ Create a new uinput device based on the source libevdev device. The uinput device will mirror all capabilities from the source device. :param source: A libevdev device with all capabilities set. :param fileobj: A file-like object to the /dev/uinput node. If None, libevdev will open the device in managed mode. See the libevdev documentation for details. """ super(UinputDevice, self).__init__() self._fileobj = fileobj if fileobj is None: fd = -2 # UINPUT_OPEN_MANAGED else: fd = fileobj.fileno() self._uinput_device = ctypes.POINTER(_UinputDevice)() rc = self._uinput_create_from_device(source._ctx, fd, ctypes.byref(self._uinput_device)) if rc != 0: raise OSError(-rc, os.strerror(-rc)) def __del__(self): if self._uinput_device is not None: self._uinput_destroy(self._uinput_device) @property def fd(self): """ :return: the file-like object used in the constructor. """ return self.fileobj def write_event(self, type, code, value): self._uinput_write_event(self._uinput_device, type, code, value) @property def devnode(self): """ Return a string with the /dev/input/eventX device node """ devnode = self._uinput_get_devnode(self._uinput_device) return devnode.decode("iso8859-1") @property def syspath(self): """ Return a string with the /dev/input/eventX device node """ syspath = self._uinput_get_syspath(self._uinput_device) return syspath.decode("iso8859-1")