+ hqcs^RIt^RIt^RIt^RIHtHt^RIHtHtHtH t ^RI H t ^RI H t !RR]4t!RR ]4t!R R ]4t!R R ]4t!RR]4t!RR]4tR#)iN)Libevdev UinputDevice)READ_FLAG_SYNCREAD_FLAG_NORMALREAD_FLAG_FORCE_SYNCREAD_FLAG_BLOCKING) InputEvent) InputPropertycs]tRt^!tRtRtR#)InvalidFileErrorzl A file provided is not a valid file descriptor for libevdev or this device must not have a file descriptor N__name__ __module__ __qualname____firstlineno____doc____static_attributes__r 4/usr/lib/python3.14/site-packages/libevdev/device.pyrr!s  rrcs4a]tRt^)toRtRRltRtRtVtR#)InvalidArgumentExceptionz A function was called with an invalid argument. This indicates a bug in the calling program. .. attribute:: message A human-readable error message NcWnR#NZmessage)selfZmsg&&r__init__Z!InvalidArgumentException.__init__2s rcVP#rrr&r__repr__Z!InvalidArgumentException.__repr__5s ||rrr) r r r rrrrr__classdictcell__Z __classdict__@rrr)srrcs]tRt^9tRtRtR#)DeviceGrabErrorzw A device grab failed to be issued. A caller must not assume that it has exclusive access to the events on the device. r Nr r rrr!r!9srr!cs]tRt^@tRtRtR#)EventsDroppedExceptiona Notification that the device has dropped events, raised in response to a EV_SYN SYN_DROPPED event. This exception is raised AFTER the EV_SYN, SYN_DROPPED event has been passed on. If SYN_DROPPED events are processed manually, then this exception can be ignored. Once received (or in response to a SYN_DROPPED event) a caller should call device.sync() and process the events accordingly (if any). Example:: fd = open("/dev/input/event0", "rb") ctx = libevdev.Device(fd) while True: try: for e in ctx.events(): print(e): except EventsDroppedException: print('State lost, re-synching:') for e in ctx.sync(): print(e) r Nr r rrr"r"@s 2 rr"cs:a]tRt^]toRtRRltRtRtRtVt R#) InputAbsInfoa A class representing the struct input_absinfo for a given EV_ABS code. Any of the attributes may be set to None, those that are None are simply ignored by libevdev. :property minimum: the minimum value for this axis :property maximum: the maximum value for this axis :property fuzz: the fuzz value for this axis :property flat: the flat value for this axis :property resolution: the resolution for this axis :property value: the current value of this axis NcsNWnW nW0nW@nWPnW`nR#r)minimummaximumfuzzflat resolutionvalue)rr$r%r&r'r(r)s&&&&&&&rrZInputAbsInfo.__init__ks     $ rcsRPVPVPVPVPVP VP 4#)z4min:{} max:{} fuzz:{} flat:{} resolution:{} value:{})Zformatr$r%r&r'r(r)rrrrZInputAbsInfo.__repr__ts;ELL||T\\499dii , ,rcs~VPVP8H;'dVPVP8H;'d}VPVP8H;'d\VPVP8H;'d;VPVP8H;'dVP VP 8H#r)r$r%r)r(r&r')rZotherrr__eq__ZInputAbsInfo.__eq__ys  -((  -(( ekk)((5#3#33(( UZZ' ((  UZZ'  )r)r'r&r%r$r(r))NNNNNN) r r r rrrrr*rrrr rr#r#]s , ))rr#csba]tRt^toRt!RR4t!RR4t!RR4tR+R lt] R 4t ] PR 4t ] R 4t ] PR 4t ] R4t ] PR4t ] R4t] R4t]PR4t] R4t]PR4t] R4t] R4tRtRt] R4t] R4t] R4tRtRtR,Rlt] R4t] R 4tR+R!ltR"t] R#4t] R$4t R+R%lt!R&t"R't#R(t$R)t%R*t&Vt'R#)-DeviceaR This class represents an evdev device backed by libevdev. The device may represent a real device in the system or a constructed device where the caller supplies all properties of the device. If a file is given, the device initializes from that file, otherwise the device is uninitialized and needs to be set up by the caller:: fd = open("/dev/input/event0", "rb") l = libevdev.Device(fd) # l now represents the device on event0 l2 = libevdev.Device() l2.name = "test device" l2.enable(libevdev.EV_REL.REL_X) # l2 is an unbound device with the REL_X bit set Note that if a device is constructed manually, the fd of the device is always None. .. note:: The device is always set to CLOCK_MONOTONIC. :param fd: fd pointing to a ``/dev/input/eventX`` event node :type fd: A file-like object cs,a]tRt^toRtRtRtVtR#)Device._EventValueSetcrr_devicerZ parent_devicerrrZDevice._EventValueSet.__init__(LrcsLVP\P8XdCV\PP8d$VPP e \ R4hVPPPVPPVP4#)NzCannot fetch value for MT axes) typelibevdevEV_ABS ABS_MT_SLOTr. num_slotsr _libevdevZ event_valuer)rcoderr __getitem__Z!Device._EventValueSet.__getitem__si X__,x222||%%1./OPP<<))55diiootzzR Rrr-N)r r r rrr9rrrr r_EventValueSetr,s ) S Srr:cs2a]tRt^toRtRtRtRtVtR#)Device._InputAbsInfoSetcrrr-r/rrrZ Device._InputAbsInfoSet.__init__r0rc s"VP\P8XgQhVPPP VP 4pVfV#\VR,VR,VR,VR,VR,VR,4#)Nr$r%r&r'r(r))r1r2r3r.r6absinfor)r#)rr8Zr&& rr9Z#Device._InputAbsInfoSet.__getitem__ss99/ // &&..tzz:Ay) a l !& 1V9 !,7= =rcs`VP\P8XgQhVPP V4'g \ R4h/pVP eVP VR&VPeVPVR&VPeVPVR&VPeVPVR&VPeVPVR&VPeVPVR&VPPPVPV4R#)zDevice does not have event codeNr$r%r&r'r(r))r1r2r3r.hasrr$r%r&r'r(r)r6r<)rr8r<datas&&& r __setitem__Z#Device._InputAbsInfoSet.__setitem__s99/ //<<##D))./PQQD*")//Y*")//Y||'&||V ||'&||V !!-%,%7%7\"}}( ' W LL " " * *4::t r6Z slot_valuerEr)r7rrr9ZDevice._SlotValue.__getitem__sm 0x222./Z[[<<##D))<<))44TZZL LrcsfVP\PJg V\PP8:d \ R4hVP P V4'g \ R4hVP PPVPVPVR7R#)rHzEvent code does not exist)Z new_valueNrI)rr8r)rGrr@ZDevice._SlotValue.__setitem__sy 0x222./Z[[<<##D))./JKK LL " " - -djj$**PU - VrrDNrArr r _SlotValuerCs  M W WrrJNcsd\V4VnRVnRVn\P V4Vn\PV4VnVe-VPP\P4R#R# \d TPP^4R#i;i)NF) rr6_uinput _is_grabbedr+r:_valuesrB _absinfos set_clock_idtimeCLOCK_MONOTONICAttributeError)rfdrrrZDevice.__init__s!"  ,,T2 006 > /++D,@,@A " /++A. /s)B&B/.B/c .VPP#)z :returns: the device name r6namerrrrV Device.name ~~"""rc&WPnR#rrU)rrVrrrVrW "rc rT)z- :returns: the device's kernel phys or None. r6physrrrr\ Device.physrXrcrYrr[)rr\rrr\r]rZrc rT)z, :returns: the device's uniq string or None r6uniqrrrr_ Device.uniq rXrcrYrr^)rr_rrr_r`rZrc rT)z' :returns: the device's driver version )r6driver_versionrrrraZDevice.driver_versions ~~,,,rc rT)a| :returns: 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 = Device() ids = {'product' : 1234} ctx.id = ids You must assign a new dictionary to ``id``. Technical limitations prohibit accessing the ``id`` dictionary itself for write access. See this example: :: $ ctx = Device() $ ctx.id['vendor'] = 1234 $ print(ctx.id['vendor']) 0 $ ctx.id = {'vendor': 1234} $ print(ctx.id['vendor']) 1234 r6idrrrrc Device.ids4~~   rcrYrrb)rZvalsrrrcrd8s  rc rT)ag This fd represents the file descriptor to this device, if any. If no fd was provided in the constructor, None is returned. If the device was used to create a uinput device, None is returned. The fd may only be changed if it was not initially None and then it overwrites the file object provided in the constructor (or a previous call to this function). The new file object becomes the object referencing this device, further events are polled from that file. .. warning:: A device initialized without a file descriptor may not change its fd. Note that libevdev does not synchronize the device and relies on the caller to ensure that the new file object points to the same device as this context. If the underlying device changes, the behavior is undefined. :raises: InvalidFileError - the file is invalid or this device does not allow a file to be set )r6rSrrrrS Device.fd<s6~~   rcs^VPPf \4hWPnVPP\P 4VP'dVP4R#R# \ dTPP^4LNi;ir) r6rSrrOrPrQrRrLgrab)rZfileobjrrrSreYs >>   $"$ $# + NN ' '(<(< =     IIK  + NN ' ' * +s)B&B,+B,c s/p\PF_pVPV4'gK.pVPF-pVPV4'gKVP V4K/ W1V&Ka V#)z Returns a dict with all supported event types and event codes, in the form of:: { libevdev.EV_ABS: [libevdev.EV_ABS.ABS_X, ...], libevdev.EV_KEY: [libevdev.EV_KEY.BTN_LEFT, ...], } )r2typesr>codesZappend)rrgtrhcs& revbitsZ Device.evbitseseA88A;;EWWxx{{ Q!H  rc s|\PUu.uFqPV4'gKVNK up#uupi)z2 Returns a list of all supported input properties )r2Zprops has_property)rps& r propertiesZDevice.properties~s- $>>B>a->->q-A>BBBs99c sLVPPVP4#)zX :param prop: a property :returns: True if the device has the property, False otherwise )r6rlr))rZproprrrlZDevice.has_propertys ~~**4::66rc sVPPVPPVP4# \d)TPPTP4u#i;i)z :param evcode: the event type or event code :type evcode: EventType or EventCode :returns: True if the device has the type and/or code, False otherwise )r6Z has_eventr1r)rR)rZevcoderrr>Z Device.hassT  :>>++FKK,=,=v||L L :>>++FLL9 9 :s9<0A/.A/c rT)z{ :returns: the number of slots on this device or ``None`` if this device does not support slots :note: Read-only )r6r5rrrr5ZDevice.num_slotss~~'''rc rT)zx :returns: the current slot on this device or ``None`` if this device does not support slots :note: Read-only )r6 current_slotrrrroZDevice.current_slots~~***rc r)a Query the device's absinfo for the given event code. This attribute can both query and modify the :class:`InputAbsInfo` values of this device:: >>> ai = d.absinfo[libevdev.EV_ABS.ABS_X] >>> print(f'Resolution is {ai.resolution}') Resolution is 33 >>> ai = d.absinfo[libevdev.EV_ABS.ABS_Z] >>> print(ai) None The returned object is a dict-like object that only accepts event codes of type `EV_ABS` as keys. No other operation than key-based access is supported. When used as a setter, the provided :class:`InputAbsInfo` becomes the new absinfo of this axis:: >>> ai = d.absinfo[libevdev.EV_ABS.ABS_X] >>> print(f'Resolution is {ai.resolution}') Resolution is 33 >>> ai.resolution = 45 >>> d.absinfo[libevdev.EV_ABS.ABS_X] = ai >>> ai = d.absinfo[libevdev.EV_ABS.ABS_X] >>> print(f'Resolution is now {ai.resolution}') Resolution is now 45 When used as a setter, any attribute of :class:`InputAbsInfo` that is ``None`` is ignored:: >>> ai = InputAbsInfo(resolution=72) >>> d.absinfo[libevdev.EV_ABS.ABS_X] = ai >>> ai = d.absinfo[libevdev.EV_ABS.ABS_X] >>> print(f'Resolution is now {ai.resolution}') Resolution is now 72 .. warning:: Setting the absinfo for a non-existing EV_ABS code is invalid. Use :func:`enable()` instead. :returns: an class:`InputAbsInfo` struct or None if the device does not have the event code :raises: :class:`InvalidArgumentException` when trying to set an axis that is not enabled. )rNrrrr<ZDevice.absinfosb~~rc  sVPV,pRVPRVPRVPRVPRVP /pVP PVPVRR7R#) au Synchronizes our view of an absinfo axis to the kernel, thus updating the the device for every other client. This function should be used with care. Not only does it change the kernel device and thus may affect the behavior of other processes but it is racy: any client that has this device node open already may never see the updates. To use this function, update the absinfo for the desired axis first:: >>> fd = open('/dev/input/event0', 'rb') >>> d = libevdev.Device(fd) >>> ai = InputAbsInfo(resolution=72) >>> d.absinfo[libevdev.EV_ABS.ABS_X] = ai >>> d.sync_absinfo_to_kernel(libevdev.EV_ABS.ABS_X) r$r%r&r'r(T)Z new_valuesZkernelN)r<r$r%r&r'r(r6r))rr8Zar?s&& rsync_absinfo_to_kernelZDevice.sync_absinfo_to_kernelse$ LL 199199all , tzzd4Hrc# sR"VPPf.#\P!VPPP 44'd\ pM\ pVPPV4pVe\P!VPVP4p\W2PVPVP4xV\P P"8Xd \%4hVPPV4pKR#5i)a Returns an iterable with currently pending events. Event processing should look like this:: fd = open("/dev/input/event0", "rb") fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK) # optional ctx = libevdev.Device(fd) while True: for e in ctx.events(): print(e): ... other mainloop code ... This function detects if the file descriptor is in blocking or non-blocking mode and adjusts its behavior accordingly. If the file descriptor is in nonblocking mode and no events are available, this function returns immediately. If the file descriptor is blocking, this function blocks if there are no events available. :returns: an iterable with the currently pending events N)r6rSosZ get_blockingZfilenorr next_eventr2evbitr1r8rr)secusecZEV_SYNZ SYN_DROPPEDr")rflagsevr8s& reventsZ Device.eventss0 >>   $I ??4>>,,335 6 6&E$E ^^ & &u -n>>"''2773DT88RVVRWW= =x222,..**51B s AD'C D'c# s"VPPf.#V'd\pM\pVPP V4pVev\ P !VPVP4p\WCPVPVP4xVPP V4pKyR#5i)a9 Returns an iterator with events pending to re-sync the caller's view of the device with the one from libevdev. :param force: if set, the device forces an internal sync. This is required after changing the fd of the device when the device state may have changed while libevdev was not processing events. N) r6rSrrrrr2rsr1r8rr)rtru)rZforcervrwr8s&& rsyncZ Device.sync s >>   $I (E"E ^^ & &u -n>>"''2773DT88RVVRWW= =**51Bs "CB#Cc r)a< Returns the current value for a given event code or None where the event code does not exist on the device:: >>> d = libevdev.Device(fd) >>> print(d.value[libevdev.EV_ABS.ABS_X]) 1024 >>> print(d.value[libevdev.EV_ABS.ABS_Y]) 512 >>> print(d.value[libevdev.EV_ABS.ABS_Z]) None The returned object is a dict-like object that only accepts event codes as keys. No other operation than key-based access is supported. The default value for all codes is 0. State-less axes like the ``EV_REL`` range always return 0 for all supported event codes. )rMrrrr)Z Device.value7s*||rc saSPf \R4h\;QJd*.V3Rl\SP44FNK 5#!V3Rl\SP444#)a Returns a tuple with the available slots, each of which contains a wrapper object to access a slot value:: >>> d = libevdev.Device(fd) >>> print(d.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X]) 1000 >>> print(d.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y]) 500 >>> print(d.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_X]) 200 >>> print(d.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_Y]) 300 Alternatively, the tuple can be iterated on:: xcode = libevdev.EV_ABS.ABS_MT_POSITION_X ycode = libevdev.EV_ABS.ABS_MT_POSITION_Y for s in d.slots: position = (s[xcode], s[ycode]) The only values available for each slot are the ones in the ``libevdev.EV_ABS.ABS_MT_*`` range (but not ``libevdev.EV_ABS.ABS_MT_SLOT``). zDevice has no slotsc3sP<"TFp\PSV4xK R#5ir)r+rJ)Z.0rFrs& rZ ZDevice.slots..ns#U?TtV&&tT22?Ts#&)r5rZtupleZrangersfrslotsZ Device.slotsNsO: >> !*+@A AuUuT^^?TUuUuUuT^^?TUUUrc  s,\V\4'd(VPPVP4R#VP \ P8XdVe\V\4'g \R4hRVP;'g^RVP;'g^RVP;'g^RVP;'g^RVP;'g^/pM.VP \ P8XdVf \R4hVPP!VP PVPV4R# \"d*TPP!TP4R#i;i) a Enable an event type or event code on this device, even if not supported by this device. If event_code is an :class:`EventType`, that type is enabled and data is ignored. If event_code is one of ``libevdev.EV_ABS.ABS_*``, then data must be a :class:`InputAbsInfo`. Any unset fields of the :class:`InputAbsInfo` are replaced with 0, i.e. the following example is valid and results in a fuzz/flat/resolution of zero:: ctx = libevdev.Device() abs = InputAbsInfo(minimum=0, maximum=100) ctx.enable(libevdev.EV_ABS.ABS_X, data) If event_code is one of ``libevdev.EV_REP.REP_``, then data must be an integer. If event_code is one of ``libevdev.INPUT_PROP_``, then the given input property is enabled. :param event_code: the event code :type event_code: EventCode or EventType :param data: if event_code is not ``None``, data points to the code-specific information. Nz.enabling EV_ABS codes requires an InputAbsInfor$r%r&r'r(z)enabling EV_REP codes requires an integer) isinstancerr6Zenable_propertyr)r1r2r3r#rr$r%r&r'r(EV_REPenablerR)r event_coder?rGrr}Z Device.enableps&: j- 0 0 NN * *:+;+; <  4(//1>> d.disable(libevdev.EV_ABS) # All EV_ABS events are filtered now >>> d.disable(libevdev.EV_KEY.BTN_LEFT) # All BTN_LEFt events are filtered now To re-enable an event type or code, use :func:`enable()` :param event_code: the event type or code :type event_code: EventType or EventCode N)r{rZNotImplementedErrorr6disabler1r)rR)rr~rrrZDevice.disablesj" j- 0 0%' ' 5 NN " ":??#8#8*:J:J K 5 NN " ":#3#3 4 5s:A0BBc VVP'gR#VPP#)zx Returns the device node for this device. The device node is None if this device has not been created as uinput device. N)rKdevnoderrrrZDevice.devnode |||||###rc r)zp Returns the syspath for this device. The syspath is None if this device has not been created as uinput device. N)rKsyspathrrrrZDevice.syspathrrc s\P!4pVPVnVPVnVPP 4Fswr4VFhpV\P 8XdVPV,pM+V\P8XdVPV,pMRpVPWV4Kj Ku VPFpVPV4K \VPV4VnV#)a= Creates and returns a new :class:`Device` based on this libevdev device. The new device is equivalent to one created with ``libevdev.Device()``, i.e. it is one that does not have a file descriptor associated. To create a uinput device from an existing device:: fd = open('/dev/input/event0', 'rb') d = libevdev.Device(fd) d.name = 'duplicated device' d.create_uinput_device() # d is now a duplicate of the event0 device with a custom name fd.close() Or to create a new device from scratch:: d = libevdev.Device() d.name = 'test device' d.enable(libevdev.EV_KEY.BTN_LEFT) d.create_uinput_device() # d is now a device with a single button :param uinput_fd: A file descriptor to the /dev/input/uinput device. If None, the device is opened and closed automatically. :raises: OSError N)r2r+rVrcrkZitemsr3r<r|r)r}rnrr6rK)rZ uinput_fdZdriZcsrjr?rms&& rcreate_uinput_deviceZDevice.create_uinput_devices6 OO ww[[&&(EA'<<?D(//)::a=DD!)A KKN!!; rc sVP'g \4hRVUu.uFq"PNK up9d \R4hRVUu.uFq"PNK up9d \R4hVFRpVPP VP PVPPVP4KT R#uupiuupi)a Send the list of :class:`InputEvent` events through this device. All events must have a valid :class:`EventCode` and value, the timestamp in the event is ignored and the kernel fills in its own timestamp. This function may only be called on a uinput device, not on a normal device. .. warning:: an event list must always be terminated with a ``libevdev.EV_SYN.SYN_REPORT`` event or the kernel may delay processing. :param events: a list of :class:`InputEvent` events Nz"All events must have an event codezAll events must have a value)rKrr8rr)Z write_eventr1)rrxZer=r send_eventsZDevice.send_eventss$|||"$ $ F+FqFFF+ +*+OP P V,VGGV, ,*+IJ JA LL $ $QVV\\166<< I ,-s C  Cc s|VPP4RTnR# \d \4hi;i)a< Exclusively grabs the device, preventing events from being seen by anyone else. This includes in-kernel consumers of the events (e.g. for rfkill) and should be used with care. A grab is valid until the file descriptor is closed or until :func:`ungrab` is called, whichever happens earlier. libevdev re-issues the grab on the device after changing the fd. If the original file descriptor is still open when changing the fd on the device, re-issuing the grab will fail silently:: fd1 = open("/dev/input/event0", "rb") d = libevdev.Device(fd1) d.grab() # device is now exclusively grabbed fd1.close() fd2 = open("/dev/input/event0", "rb") d.fd = fd2 # device is now exclusively grabbed fd3 = open("/dev/input/event0", "rb") d.fd = fd3 # ERROR: fd2 is still open and the grab fails TN)r6rfZOSErrorr!rLrrrrfZ Device.grabs;6 $ NN   !  $!# # $s%;c sJVPPR4RVnR#)z= Removes an exclusive grabs on the device, see :func:`grab`. FN)r6rfrLrrrungrabZ Device.ungrab?s E" rc sVF3pV^,P\PJgK*\R4h VF7pVPP V^,P V^,4K9 R#)a Write the LEDs to the device:: >>> fd = open(path, 'r+b', buffering=0) >>> d = libevdev.Device(fd) >>> d.set_leds([(libevdev.EV_LED.LED_NUML, 0), (libevdev.EV_LED.LED_SCROLLL, 1)]) Updating LED states require the fd to be in write-mode. z"Event code must be one of EV_LED.*N)r1r2ZEV_LEDrr6Zset_ledr))rZledsZledr=rset_ledsZDevice.set_ledsFsZC1v{{(//1./STTC NN " "3q6<<Q 8r)rNrLr6rKrMr)F)(r r r rrr:rBrJrZpropertyrVZsetterr\r_rarcrSrkrnrlr>r5ror<rprxryr)rzr}rrrrrrfrrrrrr rr+r+s#4 S S#=#=JWW2 /##  [[####  [[####  [[##-- !!6YY!!!!8YY  0CC 7 :((++00dI4&2P2.,VVB14f52$$$$-^J<  D!99rr+)rPrqr2Z_clibrrrrrrZeventrZconstrZ Exceptionrrr!r"Zobjectr#r+r rrrsj. )]]  y  y  i Y :")6")JT 9VT 9r