Repository: gvalkov/python-evdev
Branch: main
Commit: a47b5b5a6f79
Files: 45
Total size: 162.7 KB
Directory structure:
gitextract_cmbpmvbx/
├── .github/
│ └── workflows/
│ ├── install.yaml
│ ├── lint.yml
│ └── test.yml
├── .gitignore
├── .readthedocs.yaml
├── LICENSE
├── MANIFEST.in
├── README.md
├── docs/
│ ├── Makefile
│ ├── _static/
│ │ └── .keep
│ ├── _templates/
│ │ └── .keep
│ ├── apidoc.rst
│ ├── changelog.rst
│ ├── conf.py
│ ├── index.rst
│ ├── install.rst
│ ├── scope.rst
│ ├── tutorial.rst
│ └── usage.rst
├── examples/
│ └── udev-example.py
├── pyproject.toml
├── requirements-dev.txt
├── scripts/
│ ├── build-binary.sh
│ └── cibw-before.sh
├── setup.py
├── src/
│ └── evdev/
│ ├── __init__.py
│ ├── device.py
│ ├── ecodes.py
│ ├── ecodes_runtime.py
│ ├── eventio.py
│ ├── eventio_async.py
│ ├── events.py
│ ├── evtest.py
│ ├── ff.py
│ ├── genecodes_c.py
│ ├── genecodes_py.py
│ ├── input.c
│ ├── py.typed
│ ├── uinput.c
│ ├── uinput.py
│ └── util.py
└── tests/
├── test_ecodes.py
├── test_events.py
├── test_uinput.py
└── test_util.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/install.yaml
================================================
name: Test install
on:
- push
- pull_request
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest]
python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
include:
- os: ubuntu-latest
python-version: "3.9"
steps:
- uses: actions/checkout@v6
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v6
with:
python-version: ${{ matrix.python-version }}
- name: Install python-evdev
run: |
python -m pip install -v .
(cd /tmp && python -c "import evdev.ecodes; print(evdev.ecodes)")
================================================
FILE: .github/workflows/lint.yml
================================================
name: Lint
on:
- push
- pull_request
jobs:
pylint:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest]
python-version: ["3.14"]
steps:
- uses: actions/checkout@v6
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v6
with:
python-version: ${{ matrix.python-version }}
- name: Check for pylint errors
run: |
python -m pip install pylint setuptools
python setup.py build
python -m pylint --verbose -E build/lib*/evdev
================================================
FILE: .github/workflows/test.yml
================================================
name: Test
on:
- push
- pull_request
jobs:
test:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest]
python-version: ["3.14"]
steps:
- uses: actions/checkout@v6
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v6
with:
python-version: ${{ matrix.python-version }}
- name: Run pytest tests
# sudo required to write to uinputs
run: |
sudo python -m pip install pytest setuptools
sudo python -m pip install -e .
sudo python -m pytest tests
================================================
FILE: .gitignore
================================================
# --- Python ---
*.py[co]
*.egg
*.egg-info/
develop-eggs/
dist/
build/
wheelhouse/
dropin.cache
pip-log.txt
.installed.cfg
.coverage
tags
TAGS
.#*
__pycache__
.pytest_cache
.ruff_cache
.venv
uv.lock
src/evdev/*.so
src/evdev/ecodes.c
src/evdev/ecodes.pyi
docs/_build
src/evdev/_ecodes.py
src/evdev/_input.py
src/evdev/_uinput.py
================================================
FILE: .readthedocs.yaml
================================================
# https://docs.readthedocs.io/en/stable/config-file/v2.html
version: 2
build:
os: ubuntu-22.04
tools:
python: "3.12"
sphinx:
configuration: docs/conf.py
python:
install:
- requirements: requirements-dev.txt
- path: .
================================================
FILE: LICENSE
================================================
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.
================================================
FILE: MANIFEST.in
================================================
# The _ecodes extension module source file needs to be generated against the
# evdev headers of the running kernel. Refer to the 'build_ecodes' distutils
# command in setup.py.
exclude src/evdev/ecodes.c
include src/evdev/ecodes.py
================================================
FILE: README.md
================================================
# 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
================================================
FILE: docs/Makefile
================================================
# Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext ziphtml
help:
@echo "Please use \`make <target>' where <target> is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " texinfo to make Texinfo files"
@echo " info to make Texinfo files and run them through makeinfo"
@echo " gettext to make PO message catalogs"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
clean:
-rm -rf $(BUILDDIR)/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
@sed -i $(BUILDDIR)/html/index.html -e 's,<span>Synopsis</span>,<span>Python Bindings</span>,'
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/python-evdev.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/python-evdev.qhc"
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/python-evdev"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/python-evdev"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
texinfo:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
@echo "Run \`make' in that directory to run these through makeinfo" \
"(use \`make info' here to do that automatically)."
info:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo "Running Texinfo files through makeinfo..."
make -C $(BUILDDIR)/texinfo info
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
gettext:
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
@echo
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
# .PHONY: news.rst
# news.rst: changelog.rst
# cat $< | grep -FB1 '^^^^^^^^^' \
# | sed -e '/^\^/d;/--/d' -e 's,\(.*\)(\(.*\)),* **\2**: Version \1released.\n,' \
# > $@
$(BUILDDIR)/html/evdev-doc.zip: html
cd $(BUILDDIR)/html/ && zip -x \*.zip -r evdev-doc.zip .
@echo `readlink -f $@`
htmlzip: $(BUILDDIR)/html/evdev-doc.zip
================================================
FILE: docs/_static/.keep
================================================
================================================
FILE: docs/_templates/.keep
================================================
================================================
FILE: docs/apidoc.rst
================================================
API Reference
-------------
``events``
============
.. automodule:: evdev.events
:members: InputEvent, KeyEvent, AbsEvent, RelEvent, SynEvent, event_factory
:undoc-members:
:exclude-members: __dict__, __str__, __module__, __del__, __slots__, __repr__
:member-order: bysource
``eventio``
============
.. automodule:: evdev.eventio
:members: EventIO
:undoc-members:
:special-members:
:exclude-members: __dict__, __str__, __module__, __del__, __slots__, __repr__
:member-order: bysource
``eventio_async``
=================
.. automodule:: evdev.eventio_async
:members: EventIO
:undoc-members:
:special-members:
:exclude-members: __dict__, __str__, __module__, __del__, __slots__, __repr__
:member-order: bysource
``device``
============
.. automodule:: evdev.device
:members: InputDevice, DeviceInfo, AbsInfo, KbdInfo
:undoc-members:
:special-members:
:exclude-members: __dict__, __str__, __module__, __del__, __slots__, __repr__
:member-order: bysource
``uinput``
============
.. automodule:: evdev.uinput
:members: UInput
:special-members:
:exclude-members: __dict__, __str__, __module__, __del__, __slots__, __repr__
:member-order: bysource
``util``
==========
.. automodule:: evdev.util
:members: list_devices, is_device, categorize, resolve_ecodes, resolve_ecodes_dict
:member-order: bysource
``ecodes``
============
.. automodule:: evdev.ecodes
:members:
:exclude-members: __module__, keys, ecodes, bytype
:member-order: bysource
.. autodata:: evdev.ecodes.keys
:annotation: {0: 'KEY_RESERVED', 1: 'KEY_ESC', 2: 'KEY_1', ...}
.. autodata:: evdev.ecodes.ecodes
:annotation: {'KEY_END': 107, 'FF_RUMBLE': 80, 'KEY_KPDOT': 83, 'KEY_CNT': 768, ...}'
.. autodata:: evdev.ecodes.bytype
:annotation: {0: {0: 'SYN_REPORT', 1: 'SYN_CONFIG', 2: 'SYN_MT_REPORT', 3: 'SYN_DROPPED'}, ...}
================================================
FILE: docs/changelog.rst
================================================
Changelog
---------
1.9.3 (Feb 05, 2025)
====================
- Fix several memory leaks in ``input.c``.
- Raise the minimum supported Python version to 3.9 and the setuptools version to 77.0.
1.9.2 (May 01, 2025)
====================
- Add the "--reproducible" build option which removes the build date and used headers from the
generated ``ecodes.c``. Example usage::
python -m build --config-setting=--build-option='build_ecodes --reproducible' -n
- Use ``Generic`` to set precise type for ``InputDevice.path``.
1.9.1 (Feb 22, 2025)
====================
- Fix fox missing ``UI_FF`` constants in generated ``ecodes.py``.
- More type annotations.
1.9.0 (Feb 08, 2025)
====================
- Fix for ``CPATH/C_INCLUDE_PATH`` being ignored during build.
- Slightly faster reading of events in ``device.read()`` and ``device.read_one()``.
- Fix FreeBSD support.
- Drop deprecated ``InputDevice.fn`` (use ``InputDevice.path`` instead).
- Improve type hint coverage and add a ``py.typed`` file to the sdist.
1.8.0 (Jan 25, 2025)
====================
- Binary wheels are now provided by the `evdev-binary <http://pypi.python.org/pypi/evdev-binary>`_ package.
The package is compiled on manylinux_2_28 against kernel 4.18.
- The ``evdev.ecodes`` module is now generated at install time and contains only constants. This allows type
checking and introspection of the ``evdev.ecodes`` module, without having to execute it first. The old
module is available as ``evdev.ecodes_runtime``. In case generation of the static ``ecodes.py`` fails, the
install process falls back to using ``ecodes_runtime.py`` as ``ecodes.py``.
- Reverse mappings in ``evdev.ecodes`` that point to more than one value are now tuples instead of lists. For example::
>>> ecodes.KEY[153]
('KEY_DIRECTION', 'KEY_ROTATE_DISPLAY')
- Raise the minimum supported Python version to 3.8.
- Fix keyboard delay and repeat being swapped (#227).
- Move the ``syn()`` convenience method from ``InputDevice`` to ``EventIO`` (#224).
1.7.1 (May 8, 2024)
====================
- Provide fallback value for ``FF_MAX_EFFECTS``, which fixes the build on EL 7 (#219).
- Add ``#ifdef`` guards around ``UI_GET_SYSNAME`` to improve kernel compatibility (#218) .
- Wait up to two seconds for uinput devices to appear. (#215)
1.7.0 (Feb 18, 2024)
====================
- Respect the ``CPATH/C_INCLUDE_PATH`` environment variables during install.
- Add the uniq address to the string representation of ``InputDevice``.
- Improved method for finding the device node corresponding to a uinput device (`#206 <https://github.com/gvalkov/python-evdev/pull/206>`_).
- Repository TLC (reformatted with ruff, fixed linting warnings, moved packaging metadata to ``pyproject.toml`` etc.).
1.6.1 (Jan 20, 2023)
====================
- Fix generation of ``ecodes.c`` when the path to ``sys.executable`` contains spaces.
1.6.0 (Jul 17, 2022)
====================
- Fix Python 3.11 compatibility (`#174 <https://github.com/gvalkov/python-evdev/pull/174>`_).
1.5.0 (Mar 24, 2022)
====================
- Fix documentation (`#163 <https://github.com/gvalkov/python-evdev/pull/163>`_, `#160 <https://github.com/gvalkov/python-evdev/pull/160>`_).
- Re-enable TTY echo at evtest exit (`#155 <https://github.com/gvalkov/python-evdev/pull/155>`_).
- Fix ``ImportError: sys.meta_path is None, Python is likely shutting down`` (`#154 <https://github.com/gvalkov/python-evdev/pull/154>`_).
- Closing the input device file descriptor in ``InputDevice.close()`` now
happens in the main thread, instead of in a new thread (reverts `#146
<https://github.com/gvalkov/python-evdev/pull/146>`_).
- Fix ``util.find_ecodes_by_regex`` not working across all supported Python versions (`#152 <https://github.com/gvalkov/python-evdev/pull/152>`_).
1.4.0 (Jan 16, 2021)
====================
- Fix ``InputDevice.set_absinfo`` to allow setting parameters to zero.
- Fix off-by-one in ``ioctl_EVIOCG_bits``, which causes value at the end of the
list to not be reported back (`#131 <https://github.com/gvalkov/python-evdev/pull/131>`_).
- Fix ``set_absinfo`` to allow setting parameters to zero (`#128 <https://github.com/gvalkov/python-evdev/pull/128>`_).
- Fix leak when returning ``BlockingIOError`` from a read (`#143 <https://github.com/gvalkov/python-evdev/pull/143>`_).
- Fix "There is no current event loop in thread" error for non asyncio code
(`#146 <https://github.com/gvalkov/python-evdev/pull/146>`_).
- Prevent ``InputDevice`` destructor from blocking (`#145 <https://github.com/gvalkov/python-evdev/pull/145>`_).
- Add missing return codes to ``os.strerror()`` calls and fix force feedback
example in docs (`#138 <https://github.com/gvalkov/python-evdev/pull/137>`_).
- Add the ``util.find_ecodes_by_regex()`` helper function.
1.3.0 (Jan 12, 2020)
====================
- Fix build on 32bit arches with 64bit time_t
- Add functionality to query device properties. See ``InputDevice.input_props``
and the ``input_props`` argument to ``Uinput``.
- ``KeyEvent`` received an ``allow_unknown`` constructor argument, which
determines what will happen when an event code cannot be mapped to a keycode.
The default and behavior so far has been to raise ``KeyError``. If set to
``True``, the keycode will be set to the event code formatted as a hex number.
- Add ``InputDevice.set_absinfo()`` and ``InputDevice.absinfo()``.
- Instruct the asyncio event loop to stop monitoring the fd of the input device
when the device is closed.
1.2.0 (Apr 7, 2019)
====================
- Add UInput support for the resolution parameter in AbsInfo. This brings
support for the new method of uinput device setup, which was `introduced in
Linux 4.5`_ (thanks to `@LinusCDE`_).
- Vendor and product identifiers can be greater or equal to `0x8000` (thanks
`@ivaradi`_).
1.1.2 (Sep 1, 2018)
====================
- Fix installation on kernels <= 4.4.
- Fix uinput creation ignoring absinfo settings.
1.1.0 (Aug 27, 2018)
====================
- Add support for handling force-feedback effect uploads (many thanks to `@ndreys`_).
- Fix typo preventing ff effects that need left coefficients from working.
1.0.0 (Jun 02, 2018)
====================
- Prevent ``Uinput`` device creation raising ``Objects/longobject.c:415: bad
argument to internal function`` when a non-complete ``AbsInfo`` structure is
passed. All missing ``AbsInfo`` fields are set to 0.
- Fix ``Uinput`` device creation raising ``KeyError`` when a capability filtered
by default is not present.
- The ``InputDevice.fn`` attribute was deprecated in favor of ``InputDevice.path``.
Using the former will show a ``DeprecationWarning``, but would otherwise continue
working as before.
- Fix ``InputDevice`` comparison raising ``AttributeError`` due to a non-existant
``path`` attribute.
- Fix asyncio support in Python 3.5+.
- Uploading FF effect now works both on Python 2.7 and Python 3+.
- Remove the ``asyncore`` example from the tutorial.
0.8.1 (Mar 24, 2018)
====================
- Fix Python 2 compatibility issue in with ``Uinput.from_device``.
- Fix minor `evdev.evtest` formatting issue.
0.8.0 (Mar 22, 2018)
====================
- Fix ``InputDevice`` comparison on Python 2.
- The device path is now considered when comparing two devices.
- Fix ``UInput.from_device`` not correctly merging the capabilities of
selected devices.
- The list of excluded event types in ``UInput.from_device`` is now
configurable. For example::
UInput.from_device(dev, filtered_types=(EV_SYN, EV_FF))
In addition, ``ecodes.EV_FF`` is now excluded by default.
- Add a context manager for grabbing access to a device -
``InputDevice.grab_context``. For example::
with dev.grab_context():
pass
- Add the ``InputDevice.uniq`` attribute, which contains the unique identifier
of the device. As with ``phys``, this attribute may be empty (i.e. `''`).
0.7.0 (Jun 16, 2017)
====================
- ``InputDevice`` now accepts objects that support the path protocol.
For example::
pth = pathlib.Path('/dev/input/event0')
dev = evdev.InputDevice(pth)
- Support path protocol in ``InputDevice``. This means that ``InputDevice``
instances can be passed to callers that expect a ``os.PathLike`` object.
- Exceptions raised during ``InputDevice.async_read()`` (and similar) are now
handled properly (i.e. an exception is set on the returned future instead of
leaking that exception into the event loop) (Fixes `#67`_).
0.6.4 (Oct 07, 2016)
====================
- Exclude ``ecodes.c`` from source distribution (Fixes `#63`_).
0.6.3 (Oct 06, 2016)
====================
- Add the ``UInput.from_device`` class method, which allows uinput device to be
created with the capabiltiies of one or more existing input devices::
ui = UInput.from_device('/dev/input1', '/dev/input2', **constructor_kwargs)
- Add the ``build_ecodes`` distutils command, which generates the ``ecodes.c``
extension module. The new way of overwriting the evdev header locations is::
python setup.py build \
build_ecodes --evdev-headers path/input.h:path/input-event-codes.h \
build_ext --include-dirs path/ \
install
The ``build*`` and ``install`` commands no longer have to be part of the same
command-line (i.e. running ``install`` will reuse the outputs of the last
``build``).
0.6.1 (Jun 04, 2016)
====================
- Disable tty echoing while evtest is running.
- Allow evtest to listen to more than one devices.
- The setup.py script now allows the location of the input header files to be
overwritten. For example::
python setup.py build_ext \
--evdev-headers path/input.h:path/input-event-codes.h \
--include-dirs path/ \
install
0.6.0 (Feb 14, 2016)
====================
- Asyncio and async/await support (many thanks to `@paulo-raca`_).
- Add the ability to set the `phys` property of uinput devices (thanks `@paulo-raca`_).
- Add a generic :func:`InputDevice.set` method (thanks `@paulo-raca`_).
- Distribute the evtest script along with evdev.
- Fix issue with generating :mod:`ecodes.c` in recent kernels (``>= 4.4.0``).
- Fix absinfo item indexes in :func:`UInput.uinput_create()` (thanks `@forsenonlhaimaisentito`_).
- More robust comparison of :class:`InputDevice` objects (thanks `@isia`_).
0.5.0 (Jun 16, 2015)
====================
- Write access to the input device is no longer mandatory. Evdev will
first try to open the device for reading and writing and fallback to
read-only. Methods that require write access (e.g. :func:`set_led()`)
will raise :class:`EvdevError` if the device is open only for reading.
0.4.7 (Oct 07, 2014)
====================
- Fallback to distutils if setuptools is not available.
0.4.6 (Oct 07, 2014)
====================
- Rework documentation and docstrings once more.
- Fix install on Python 3.4 (works around issue21121_).
- Fix :func:`ioctl()` requested buffer size (thanks Jakub Wojciech Klama).
0.4.5 (Jul 06, 2014)
====================
- Add method for returning a list of the currently active keys -
:func:`InputDevice.active_keys()` (thanks `@spasche`_).
- Fix a potential buffer overflow in :func:`ioctl_capabilities()` (thanks `@spasche`_).
0.4.4 (Jun 04, 2014)
====================
- Calling :func:`InputDevice.read_one()` should always return ``None``,
when there is nothing to be read, even in case of a ``EAGAIN`` errno
(thanks JPP).
0.4.3 (Dec 19, 2013)
====================
- Silence :class:`OSError` in destructor (thanks `@polyphemus`_).
- Make :func:`InputDevice.close()` work in cases in which stdin (fd 0)
has been closed (thanks `@polyphemus`_).
0.4.2 (Dec 13, 2013)
====================
- Rework documentation and docstrings.
- Call :func:`InputDevice.close()` from :func:`InputDevice.__del__()`.
0.4.1 (Jul 24, 2013)
====================
- Fix reference counting in :func:`InputDevice.device_read()`,
:func:`InputDevice.device_read_many()` and :func:`ioctl_capabilities`.
0.4.0 (Jul 01, 2013)
====================
- Add ``FF_*`` and ``FF_STATUS`` codes to :func:`ecodes` (thanks `@bgilbert`_).
- Reverse event code mappings (``ecodes.{KEY,FF,REL,ABS}`` and etc.)
will now map to a list of codes, whenever a value corresponds to
multiple codes::
>>> ecodes.KEY[152]
... ['KEY_COFFEE', 'KEY_SCREENLOCK']
>>> ecodes.KEY[30]
... 'KEY_A'
- Set the state of a LED through :func:`InputDevice.set_led()` (thanks
`@accek`_).
- Open :attr:`InputDevice.fd` in ``O_RDWR`` mode from now on.
- Fix segfault in :func:`InputDevice.device_read_many()` (thanks `@bgilbert`_).
0.3.3 (May 29, 2013)
====================
- Raise :class:`IOError` from :func:`InputDevice.device_read()` and
:func:`InputDevice.device_read_many()` when :func:`InputDevice.read()`
fails.
- Several stability and style changes (thank you debian code reviewers).
0.3.2 (Apr 05, 2013)
====================
- Fix vendor id and product id order in :func:`DeviceInfo` (thanks `@kived`_).
0.3.1 (Nov 23, 2012)
====================
- :func:`InputDevice.read()` will return an empty tuple if the device
has nothing to offer (instead of segfaulting).
- Exclude unnecessary package data in sdist and bdist.
0.3.0 (Nov 06, 2012)
====================
- Add ability to set/get auto-repeat settings with ``EVIOC{SG}REP``.
- Add :func:`InputDevice.version` - the value of ``EVIOCGVERSION``.
- Add :func:`InputDevice.read_loop()`.
- Add :func:`InputDevice.grab()` and :func:`InputDevice.ungrab()` -
exposes ``EVIOCGRAB``.
- Add :func:`InputDevice.leds` - exposes ``EVIOCGLED``.
- Replace :class:`DeviceInfo` class with a namedtuple.
- Prevent :func:`InputDevice.read_one()` from skipping events.
- Rename :class:`AbsData` to :class:`AbsInfo` (as in ``struct input_absinfo``).
0.2.0 (Aug 22, 2012)
====================
- Add the ability to set arbitrary device capabilities on uinput
devices (defaults to all ``EV_KEY`` ecodes).
- Add :attr:`UInput.device` which is an open :class:`InputDevice` to
the input device that uinput 'spawns'.
- Add :func:`UInput.capabilities()` which is just a shortcut to
:func:`UInput.device.capabilities()`.
- Rename :func:`UInput.write()` to :func:`UInput.write_event()`.
- Add a simpler :func:`UInput.write(type, code, value)` method.
- Make all :func:`UInput` constructor arguments optional (default
device name is now ``py-evdev-uinput``).
- Add the ability to set ``absmin``, ``absmax``, ``absfuzz`` and
``absflat`` when specifying the uinput device's capabilities.
- Remove the ``nophys`` argument - if a device fails the
``EVIOCGPHYS`` ioctl, phys will equal the empty string.
- Make :func:`InputDevice.capabilities()` perform a ``EVIOCGABS``
ioctl for devices that support ``EV_ABS`` and return that info
wrapped in an ``AbsData`` namedtuple.
- Split ``ioctl_devinfo`` into ``ioctl_devinfo`` and
``ioctl_capabilities``.
- Split :func:`UInput.uinput_open()` to :func:`UInput.uinput_open()`
and :func:`UInput.uinput_create()`
- Add more uinput usage examples and documentation.
- Rewrite uinput tests.
- Remove ``mouserel`` and ``mouseabs`` from :class:`UInput`.
- Tie the sphinx version and release to the distutils version.
- Set 'methods-before-attributes' sorting in the docs.
- Remove ``KEY_CNT`` and ``KEY_MAX`` from :func:`ecodes.keys`.
0.1.1 (May 18, 2012)
====================
- Add ``events.keys``, which is a combination of all ``BTN_`` and
``KEY_`` event codes.
- ``ecodes.c`` was not generated when installing through ``pip``.
0.1.0 (May 17, 2012)
====================
*Initial Release*
.. _`@polyphemus`: https://github.com/polyphemus
.. _`@bgilbert`: https://github.com/bgilbert
.. _`@accek`: https://github.com/accek
.. _`@kived`: https://github.com/kived
.. _`@spasche`: https://github.com/spasche
.. _`@isia`: https://github.com/isia
.. _`@forsenonlhaimaisentito`: https://github.com/forsenonlhaimaisentito
.. _`@paulo-raca`: https://github.com/paulo-raca
.. _`@ndreys`: https://github.com/ndreys
.. _`@LinusCDE`: https://github.com/gvalkov/python-evdev/pulls/LinusCDE
.. _`@ivaradi`: https://github.com/gvalkov/python-evdev/pull/104
.. _`introduced in Linux 4.5`: https://github.com/torvalds/linux/commit/052876f8e5aec887d22c4d06e54aa5531ffcec75
.. _issue21121: http://bugs.python.org/issue21121
.. _`#63`: https://github.com/gvalkov/python-evdev/issues/63
.. _`#67`: https://github.com/gvalkov/python-evdev/issues/67
================================================
FILE: docs/conf.py
================================================
import os
import sys
import sphinx_rtd_theme
# Check if readthedocs is building us
on_rtd = os.environ.get("READTHEDOCS", None) == "True"
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
# Trick autodoc into running without having built the extension modules.
if on_rtd:
with open("../src/evdev/_ecodes.py", "w") as fh:
fh.write(
"""
KEY = ABS = REL = SW = MSC = LED = REP = SND = SYN = FF = FF_STATUS = BTN_A = KEY_A = 1
EV_KEY = EV_ABS = EV_REL = EV_SW = EV_MSC = EV_LED = EV_REP = 1
EV_SND = EV_SYN = EV_FF = EV_FF_STATUS = FF_STATUS = 1
KEY_MAX, KEY_CNT = 1, 2"""
)
with open("../src/evdev/_input.py", "w"):
pass
with open("../src/evdev/_uinput.py", "w"):
pass
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.viewcode",
"sphinx.ext.intersphinx",
"sphinx.ext.napoleon",
"sphinx_rtd_theme",
"sphinx_copybutton",
]
autodoc_member_order = "bysource"
# Add any paths that contain templates here, relative to this directory.
templates_path = ["_templates"]
# The suffix of source filenames.
source_suffix = ".rst"
# The encoding of source files.
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = "index"
# General information about the project.
project = "python-evdev"
copyright = "2012-2025, Georgi Valkov and contributors"
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The full version, including alpha/beta/rc tags.
release = "1.9.3"
# The short X.Y version.
version = release
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
# language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
# today = ''
# Else, today_fmt is used as the format for a strftime call.
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ["_build"]
# The reST default role (used for this markup: `text`) to use for all documents.
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
# pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = "sphinx_rtd_theme"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
# html_theme_options = {"full_logo" : True}
# Add any paths that contain custom themes here, relative to this directory.
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
html_title = "Python-evdev"
# A shorter title for the navigation bar. Default is the same as html_title.
html_short_title = "evdev"
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
# html_logo = ''
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ["_static"]
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
# html_additional_pages = {}
# If false, no module index is generated.
# html_domain_indices = True
# If false, no index is generated.
# html_use_index = True
# If true, the index is split into individual pages for each letter.
# html_split_index = False
# If true, links to the reST sources are added to the pages.
html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = "python-evdev-doc"
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
("index", "python-evdev.tex", "evdev documentation", "Georgi Valkov", "manual"),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
# latex_use_parts = False
# If true, show page references after internal links.
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
# latex_appendices = []
# If false, no module index is generated.
# latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [("index", "python-evdev", "python-evdev Documentation", ["Georgi Valkov"], 1)]
# If true, show URL addresses after external links.
# man_show_urls = False
# -- Options for Texinfo output ------------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(
"index",
"python-evdev",
"python-evdev Documentation",
"Georgi Valkov",
"evdev",
"Bindings for the linux input handling subsystem.",
"Miscellaneous",
),
]
intersphinx_mapping = {"python": ("http://docs.python.org/3", None)}
# Documents to append as an appendix to all manuals.
# texinfo_appendices = []
# If false, no module index is generated.
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
# texinfo_show_urls = 'footnote'
# Copybutton config
# copybutton_prompt_text = r">>> "
# copybutton_prompt_is_regexp = True
# copybutton_only_copy_prompt_lines = True
================================================
FILE: docs/index.rst
================================================
Introduction
------------
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.
In other words, *python-evdev* allows you to read and write input
events on Linux. An event can be a key or button press, a mouse
movement or a tap on a touchscreen.
.. toctree::
:caption: Installation
:maxdepth: 2
install
.. toctree::
:caption: Usage
usage
tutorial
apidoc
.. toctree::
:caption: Project
:maxdepth: 2
scope
changelog
License
-------
This package is released under the terms of the `Revised BSD License`_.
.. _`Revised BSD License`: https://raw.github.com/gvalkov/python-evdev/master/LICENSE
.. _evdev: http://svn.navi.cx/misc/trunk/python/evdev/
================================================
FILE: docs/install.rst
================================================
From an OS package
==================
Python-evdev has been packaged for the following distributions:
.. raw:: html
<a href="https://repology.org/project/python:evdev/versions">
<img src="https://repology.org/badge/vertical-allrepos/python:evdev.svg?exclude_sources=modules,site&exclude_unsupported=1" alt="Packaging status">
</a>
Consult the documentation of your OS package manager for installation instructions.
From source
===========
The latest stable version of *python-evdev* can be installed from pypi_,
provided that you have a compiler, pip_ and the Python and Linux development
headers installed on your system. Installing these is distribution specific and
typically falls into one of the following:
On a Debian compatible OS:
.. code-block:: bash
$ apt install python-dev python-pip gcc
$ apt install linux-headers-$(uname -r)
On a Redhat compatible OS:
.. code-block:: bash
$ dnf install python-devel python-pip gcc
$ dnf install kernel-headers-$(uname -r)
On Arch Linux and derivatives:
.. code-block:: bash
$ pacman -S core/linux-api-headers python-pip gcc
Once all OS dependencies are available, you may install *python-evdev* using
pip_, preferably in a [virtualenv]_:
.. code-block:: bash
# Install globally (not recommended).
$ sudo python3 -m pip install evdev
# Install for the current user.
$ python3 -m pip install --user evdev
# Install in a virtual environment.
$ python3 -m venv abc
$ source abc/bin/activate
$ python3 -m pip install evdev
Specifying header locations
---------------------------
By default, the setup script will look for the ``input.h`` and
``input-event-codes.h`` [#f1]_ header files ``/usr/include/linux``.
You may use the ``--evdev-headers`` option to the ``build_ext`` setuptools
command to the location of these header files. It accepts one or more
colon-separated paths. For example:
.. code-block:: bash
$ python setup.py build_ext \
--evdev-headers buildroot/input.h:buildroot/input-event-codes.h \
--include-dirs buildroot/ \
install # or any other command (e.g. develop, bdist, bdist_wheel)
From a binary package
=====================
You may choose to install a precompiled version of *python-evdev* from pypi. The
`evdev-binary`_ package provides binary wheels that have been compiled on EL8
against the 4.18.0 kernel headers.
.. code-block:: bash
$ python3 -m pip install evdev-binary
While the evdev interface is stable, the precompiled version may not be fully
compatible or expose all the features of your running kernel. For best results,
it is recommended to use an OS package or to install from source.
.. [#f1] ``input-event-codes.h`` is found only in recent kernel versions.
.. _pypi: http://pypi.python.org/pypi/evdev
.. _evdev-binary: http://pypi.python.org/pypi/evdev-binary
.. _github: https://github.com/gvalkov/python-evdev
.. _pip: http://pip.readthedocs.org/en/latest/installing.html
.. _example: https://github.com/gvalkov/python-evdev/tree/master/examples
.. _virtualenv: https://docs.python.org/3/library/venv.html
================================================
FILE: docs/scope.rst
================================================
Scope and status
----------------
Python-evdev exposes most of the more common interfaces defined in the evdev
subsystem. Reading and injecting events is well supported and has been tested
with nearly all event types.
The basic functionality for reading and uploading force-feedback events is
there, but it has not been exercised sufficiently. A major shortcoming of the
uinput wrapper is that it does not support force-feedback devices at all (see
issue `#23`_).
Some characters, such as ``:`` (colon), cannot be easily injected (see issue
`#7`_), Translating them into UInput events would require knowing the kernel
keyboard translation table, which is beyond the scope of python-evdev. Please
look into the following projects if you need more complete or convenient input
injection support.
- python-uinput_
- uinput-mapper_
- pynput_
- pygame_ (cross-platform)
.. _python-uinput: https://github.com/tuomasjjrasanen/python-uinput
.. _uinput-mapper: https://github.com/MerlijnWajer/uinput-mapper
.. _pynput: https://github.com/moses-palmer/pynput
.. _pygame: http://www.pygame.org/
.. _`#7`: https://github.com/gvalkov/python-evdev/issues/7
.. _`#23`: https://github.com/gvalkov/python-evdev/pull/23
================================================
FILE: docs/tutorial.rst
================================================
Tutorial
--------
Listing accessible event devices
================================
::
>>> import evdev
>>> devices = [evdev.InputDevice(path) for path in evdev.list_devices()]
>>> for device in devices:
>>> print(device.path, device.name, device.phys)
/dev/input/event1 Dell Dell USB Keyboard usb-0000:00:12.1-2/input0
/dev/input/event0 Dell USB Optical Mouse usb-0000:00:12.0-2/input0
Listing device capabilities
===========================
::
>>> import evdev
>>> device = evdev.InputDevice('/dev/input/event0')
>>> print(device)
device /dev/input/event0, name "Dell USB Optical Mouse", phys "usb-0000:00:12.0-2/input0"
>>> device.capabilities()
... { 0: [0, 1, 2], 1: [272, 273, 274, 275], 2: [0, 1, 6, 8], 4: [4] }
>>> device.capabilities(verbose=True)
... { ('EV_SYN', 0): [('SYN_REPORT', 0), ('SYN_CONFIG', 1), ('SYN_MT_REPORT', 2)],
... ('EV_KEY', 1): [('BTN_MOUSE', 272), ('BTN_RIGHT', 273), ('BTN_MIDDLE', 274), ('BTN_SIDE', 275)], ...
Listing device capabilities (devices with absolute axes)
========================================================
::
>>> import evdev
>>> device = evdev.InputDevice('/dev/input/event7')
>>> print(device)
device /dev/input/event7, name "Wacom Bamboo 2FG 4x5 Finger", phys ""
>>> device.capabilities()
... { 1: [272, 273, 277, 278, 325, 330, 333] ,
... 3: [(0, AbsInfo(min=0, max=15360, fuzz=128, flat=0)),
... (1, AbsInfo(min=0, max=10240, fuzz=128, flat=0))] }
>>> device.capabilities(verbose=True)
... { ('EV_KEY', 1): [('BTN_MOUSE', 272), ('BTN_RIGHT', 273), ...],
... ('EV_ABS', 3): [(('ABS_X', 0), AbsInfo(min=0, max=15360, fuzz=128, flat=0)),
... (('ABS_Y', 1), AbsInfo(min=0, max=10240, fuzz=128, flat=0)),] }
>>> device.capabilities(absinfo=False)
... { 1: [272, 273, 277, 278, 325, 330, 333],
... 3: [0, 1, 47, 53, 54, 57] }
Getting and setting LED states
==============================
::
>>> dev.leds(verbose=True)
... [('LED_NUML', 0), ('LED_CAPSL', 1)]
>>> dev.leds()
... [0, 1]
>>> dev.set_led(ecodes.LED_NUML, 1) # enable numlock
>>> dev.set_led(ecodes.LED_NUML, 0) # disable numlock
Getting currently active keys
=============================
::
>>> dev.active_keys(verbose=True)
... [('KEY_3', 4), ('KEY_LEFTSHIFT', 42)]
>>> dev.active_keys()
... [4, 42]
Reading events
==============
Reading events from a single device in an endless loop.
::
>>> from evdev import InputDevice, categorize, ecodes
>>> dev = InputDevice('/dev/input/event1')
>>> print(dev)
device /dev/input/event1, name "Dell Dell USB Keyboard", phys "usb-0000:00:12.1-2/input0"
>>> for event in dev.read_loop():
... if event.type == ecodes.EV_KEY:
... print(categorize(event))
... # pressing 'a' and holding 'space'
key event at 1337016188.396030, 30 (KEY_A), down
key event at 1337016188.492033, 30 (KEY_A), up
key event at 1337016189.772129, 57 (KEY_SPACE), down
key event at 1337016190.275396, 57 (KEY_SPACE), hold
key event at 1337016190.284160, 57 (KEY_SPACE), up
Reading events (using :mod:`asyncio`)
======================================
.. note::
This requires Python 3.5+ for the async/await keywords.
::
>>> import asyncio
>>> from evdev import InputDevice
>>> dev = InputDevice('/dev/input/event1')
>>> async def main(dev):
... async for ev in dev.async_read_loop():
... print(repr(ev))
>>> asyncio.run(main(dev))
InputEvent(1527363738, 348740, 4, 4, 458792)
InputEvent(1527363738, 348740, 1, 28, 0)
InputEvent(1527363738, 348740, 0, 0, 0)
Reading events from multiple devices (using :mod:`select`)
==========================================================
::
>>> from evdev import InputDevice
>>> from select import select
# A mapping of file descriptors (integers) to InputDevice instances.
>>> devices = map(InputDevice, ('/dev/input/event1', '/dev/input/event2'))
>>> devices = {dev.fd: dev for dev in devices}
>>> for dev in devices.values(): print(dev)
device /dev/input/event1, name "Dell Dell USB Keyboard", phys "usb-0000:00:12.1-2/input0"
device /dev/input/event2, name "Logitech USB Laser Mouse", phys "usb-0000:00:12.0-2/input0"
>>> while True:
... r, w, x = select(devices, [], [])
... for fd in r:
... for event in devices[fd].read():
... print(event)
event at 1351116708.002230, code 01, type 02, val 01
event at 1351116708.002234, code 00, type 00, val 00
event at 1351116708.782231, code 04, type 04, val 458782
event at 1351116708.782237, code 02, type 01, val 01
Reading events from multiple devices (using :mod:`selectors`)
=============================================================
This can also be achieved using the :mod:`selectors` module in Python 3.4:
::
from evdev import InputDevice
from selectors import DefaultSelector, EVENT_READ
selector = DefaultSelector()
mouse = InputDevice('/dev/input/event1')
keybd = InputDevice('/dev/input/event2')
# This works because InputDevice has a `fileno()` method.
selector.register(mouse, EVENT_READ)
selector.register(keybd, EVENT_READ)
while True:
for key, mask in selector.select():
device = key.fileobj
for event in device.read():
print(event)
Reading events from multiple devices (using :mod:`asyncio`)
===========================================================
Yet another possibility is the :mod:`asyncio` module from Python 3.4:
::
import asyncio, evdev
@asyncio.coroutine
def print_events(device):
while True:
events = yield from device.async_read()
for event in events:
print(device.path, evdev.categorize(event), sep=': ')
mouse = evdev.InputDevice('/dev/input/eventX')
keybd = evdev.InputDevice('/dev/input/eventY')
for device in mouse, keybd:
asyncio.async(print_events(device))
loop = asyncio.get_event_loop()
loop.run_forever()
Since Python 3.5, the `async/await`_ syntax makes this even simpler:
::
import asyncio, evdev
mouse = evdev.InputDevice('/dev/input/event4')
keybd = evdev.InputDevice('/dev/input/event5')
async def print_events(device):
async for event in device.async_read_loop():
print(device.path, evdev.categorize(event), sep=': ')
for device in mouse, keybd:
asyncio.ensure_future(print_events(device))
loop = asyncio.get_event_loop()
loop.run_forever()
Accessing evdev constants
=========================
::
>>> from evdev import ecodes
>>> ecodes.KEY_A, ecodes.ecodes['KEY_A']
... (30, 30)
>>> ecodes.KEY[30]
... 'KEY_A'
>>> ecodes.bytype[ecodes.EV_KEY][30]
... 'KEY_A'
>>> ecodes.KEY[152] # a single value may correspond to multiple codes
... ['KEY_COFFEE', 'KEY_SCREENLOCK']
Searching event codes by regex
==============================
::
>>> from evdev import util
>>> res = util.find_ecodes_by_regex(r'(ABS|KEY)_BR(AKE|EAK)')
>>> res
... {1: [411], 3: [10]}
>>> util.resolve_ecodes_dict(res)
... {('EV_KEY', 1): [('KEY_BREAK', 411)], ('EV_ABS', 3): [('ABS_BRAKE', 10)]}
Getting exclusive access to a device
====================================
::
>>> dev.grab() # become the sole recipient of all incoming input events
>>> dev.ungrab()
This functionality is also available as a context manager.
::
>>> with dev.grab_context():
... pass
Associating classes with event types
====================================
::
>>> from evdev import categorize, event_factory, ecodes
>>> class SynEvent:
... def __init__(self, event):
... ...
>>> event_factory[ecodes.EV_SYN] = SynEvent
See :mod:`events <evdev.events.event_factory>` for more information.
Injecting input
===============
::
>>> from evdev import UInput, ecodes as e
>>> ui = UInput()
>>> # accepts only KEY_* events by default
>>> ui.write(e.EV_KEY, e.KEY_A, 1) # KEY_A down
>>> ui.write(e.EV_KEY, e.KEY_A, 0) # KEY_A up
>>> ui.syn()
>>> ui.close()
Injecting events (using a context manager)
==========================================
::
>>> ev = InputEvent(1334414993, 274296, ecodes.EV_KEY, ecodes.KEY_A, 1)
>>> with UInput() as ui:
... ui.write_event(ev)
... ui.syn()
Specifying ``uinput`` device options
====================================
.. note::
``ecodes.EV_SYN`` cannot be in the ``cap`` dictionary or the device will not be created.
::
>>> from evdev import UInput, AbsInfo, ecodes as e
>>> cap = {
... e.EV_KEY : [e.KEY_A, e.KEY_B],
... e.EV_ABS : [
... (e.ABS_X, AbsInfo(value=0, min=0, max=255,
... fuzz=0, flat=0, resolution=0)),
... (e.ABS_Y, AbsInfo(0, 0, 255, 0, 0, 0)),
... (e.ABS_MT_POSITION_X, (0, 128, 255, 0)) ]
... }
>>> ui = UInput(cap, name='example-device', version=0x3)
>>> print(ui)
name "example-device", bus "BUS_USB", vendor "0001", product "0001", version "0003"
event types: EV_KEY EV_ABS EV_SYN
>>> print(ui.capabilities())
{0: [0, 1, 3],
1: [30, 48],
3: [(0, AbsInfo(value=0, min=0, max=0, fuzz=255, flat=0, resolution=0)),
(1, AbsInfo(value=0, min=0, max=0, fuzz=255, flat=0, resolution=0)),
(53, AbsInfo(value=0, min=0, max=255, fuzz=128, flat=0, resolution=0))]}
>>> # move mouse cursor
>>> ui.write(e.EV_ABS, e.ABS_X, 20)
>>> ui.write(e.EV_ABS, e.ABS_Y, 20)
>>> ui.syn()
Create ``uinput`` device with capabilities of another device
================================================================
::
>>> from evdev import UInput, InputDevice
>>> mouse = InputDevice('/dev/input/event1')
>>> keybd = '/dev/input/event2'
>>> ui = UInput.from_device(mouse, keybd, name='keyboard-mouse-device')
>>> ui.capabilities(verbose=True).keys()
dict_keys([('EV_LED', 17), ('EV_KEY', 1), ('EV_SYN', 0), ('EV_REL', 2), ('EV_MSC', 4)])
.. _`async/await`: https://docs.python.org/3/library/asyncio-task.html
Create ``uinput`` device capable of receiving FF-effects
========================================================
::
import asyncio
from evdev import UInput, categorize, ecodes
cap = {
ecodes.EV_FF: [ecodes.FF_RUMBLE ],
ecodes.EV_KEY: [ecodes.KEY_A, ecodes.KEY_B]
}
ui = UInput(cap, name='test-controller', version=0x3)
async def print_events(device):
async for event in device.async_read_loop():
print(categorize(event))
# Wait for an EV_UINPUT event that will signal us that an
# effect upload/erase operation is in progress.
if event.type != ecodes.EV_UINPUT:
continue
if event.code == ecodes.UI_FF_UPLOAD:
upload = device.begin_upload(event.value)
upload.retval = 0
print(f'[upload] effect_id: {upload.effect.id}, type: {upload.effect.type}')
device.end_upload(upload)
elif event.code == ecodes.UI_FF_ERASE:
erase = device.begin_erase(event.value)
print(f'[erase] effect_id {erase.effect_id}')
erase.retval = 0
device.end_erase(erase)
asyncio.ensure_future(print_events(ui))
loop = asyncio.get_event_loop()
loop.run_forever()
Injecting an FF-event into first FF-capable device found
========================================================
::
from evdev import ecodes, InputDevice, ff, list_devices
import time
# Find first EV_FF capable event device (that we have permissions to use).
for name in list_devices():
dev = InputDevice(name)
if ecodes.EV_FF in dev.capabilities():
break
rumble = ff.Rumble(strong_magnitude=0x0000, weak_magnitude=0xffff)
effect_type = ff.EffectType(ff_rumble_effect=rumble)
duration_ms = 1000
effect = ff.Effect(
ecodes.FF_RUMBLE, -1, 0,
ff.Trigger(0, 0),
ff.Replay(duration_ms, 0),
effect_type
)
repeat_count = 1
effect_id = dev.upload_effect(effect)
dev.write(ecodes.EV_FF, effect_id, repeat_count)
time.sleep(duration_ms / 1000)
dev.erase_effect(effect_id)
Forwarding force-feedback from uinput to a real device
======================================================
::
import evdev
from evdev import ecodes as e
# Find first EV_FF capable event device (that we have permissions to use).
for name in evdev.list_devices():
dev = evdev.InputDevice(name)
if e.EV_FF in dev.capabilities():
break
# To ensure forwarding works correctly it is important that `max_effects`
# of the uinput device is <= `dev.ff_effects_count`.
# `from_device()` will do this automatically, but in some situations you may
# want to set the `max_effects` parameter manually, such as when using `Uinput()`.
# `filtered_types` is specified as by default EV_FF events are filtered
uinput = evdev.UInput.from_device(dev, filtered_types=[e.EV_SYN])
# Keeps track of which effects have been uploaded to the device
effects = set()
for event in uinput.read_loop():
# Handle the special uinput events
if event.type == e.EV_UINPUT:
if event.code == e.UI_FF_UPLOAD:
upload = uinput.begin_upload(event.value)
# Checks if this is a new effect
if upload.effect.id not in effects:
effects.add(upload.effect.id)
# Setting id to 1 indicates that a new effect must be allocated
upload.effect.id = -1
dev.upload_effect(upload.effect)
upload.retval = 0
uinput.end_upload(upload)
elif event.code == e.UI_FF_ERASE:
erase = uinput.begin_erase(event.value)
erase.retval = 0
dev.erase_effect(erase.effect_id)
effects.remove(erase.effect_id)
uinput.end_erase(erase)
# Forward writes to actual rumble device.
elif event.type == e.EV_FF:
dev.write(event.type, event.code, event.value)
================================================
FILE: docs/usage.rst
================================================
Quick Start
-----------
Listing accessible event devices
================================
::
>>> import evdev
>>> devices = [evdev.InputDevice(path) for path in evdev.list_devices()]
>>> for device in devices:
... print(device.path, device.name, device.phys)
/dev/input/event1 USB Keyboard usb-0000:00:12.1-2/input0
/dev/input/event0 USB Optical Mouse usb-0000:00:12.0-2/input0
.. note::
If you do not see any devices, ensure that your user is in the
correct group (typically ``input``) to have read/write access.
Reading events from a device
============================
::
>>> import evdev
>>> device = evdev.InputDevice('/dev/input/event1')
>>> print(device)
device /dev/input/event1, name "USB Keyboard", phys "usb-0000:00:12.1-2/input0"
>>> for event in device.read_loop():
... if event.type == evdev.ecodes.EV_KEY:
... print(evdev.categorize(event))
... # pressing 'a' and holding 'space'
key event at 1337016188.396030, 30 (KEY_A), down
key event at 1337016188.492033, 30 (KEY_A), up
key event at 1337016189.772129, 57 (KEY_SPACE), down
key event at 1337016190.275396, 57 (KEY_SPACE), hold
key event at 1337016190.284160, 57 (KEY_SPACE), up
Accessing event codes
=====================
The ``evdev.ecodes`` module provides reverse and forward mappings between the
names and values of the event subsystem constants.
::
>>> from evdev import ecodes
>>> ecodes.KEY_A
... 30
>>> ecodes.ecodes['KEY_A']
... 30
>>> ecodes.KEY[30]
... 'KEY_A'
>>> ecodes.bytype[ecodes.EV_KEY][30]
... 'KEY_A'
# A single value may correspond to multiple event codes.
>>> ecodes.KEY[152]
... ['KEY_COFFEE', 'KEY_SCREENLOCK']
Listing and monitoring input devices
====================================
The *python-evdev* package also comes with a small command-line program for
listing and monitoring input devices:
.. code-block:: bash
$ python -m evdev.evtest
================================================
FILE: examples/udev-example.py
================================================
#!/usr/bin/env python3
"""
This is an example of using pyudev[1] alongside evdev.
[1]: https://pyudev.readthedocs.org/
"""
import functools
import pyudev
from select import select
from evdev import InputDevice
context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by(subsystem="input")
monitor.start()
fds = {monitor.fileno(): monitor}
finalizers = []
while True:
r, w, x = select(fds, [], [])
if monitor.fileno() in r:
r.remove(monitor.fileno())
for udev in iter(functools.partial(monitor.poll, 0), None):
# we're only interested in devices that have a device node
# (e.g. /dev/input/eventX)
if not udev.device_node:
break
# find the device we're interested in and add it to fds
for name in (i["NAME"] for i in udev.ancestors if "NAME" in i):
# I used a virtual input device for this test - you
# should adapt this to your needs
if "py-evdev-uinput" in name:
if udev.action == "add":
print("Device added: %s" % udev)
fds[dev.fd] = InputDevice(udev.device_node)
break
if udev.action == "remove":
print("Device removed: %s" % udev)
def helper():
global fds
fds = {monitor.fileno(): monitor}
finalizers.append(helper)
break
for fd in r:
dev = fds[fd]
for event in dev.read():
print(event)
for i in range(len(finalizers)):
finalizers.pop()()
================================================
FILE: pyproject.toml
================================================
[build-system]
requires = ["setuptools>=77.0"]
build-backend = "setuptools.build_meta"
[project]
name = "evdev"
version = "1.9.3"
description = "Bindings to the Linux input handling subsystem"
keywords = ["evdev", "input", "uinput"]
readme = "README.md"
license = "BSD-3-Clause"
requires-python = ">=3.9"
authors = [
{ name="Georgi Valkov", email="georgi.t.valkov@gmail.com" },
]
maintainers = [
{ name="Tobi", email="proxima@sezanzeb.de" },
]
classifiers = [
"Development Status :: 5 - Production/Stable",
"Programming Language :: Python :: 3",
"Operating System :: POSIX :: Linux",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries",
"Programming Language :: Python :: Implementation :: CPython",
]
[project.urls]
"Homepage" = "https://github.com/gvalkov/python-evdev"
[tool.ruff]
line-length = 120
[tool.ruff.lint]
ignore = ["E265", "E241", "F403", "F401", "E401", "E731"]
[tool.bumpversion]
current_version = "1.9.3"
commit = true
tag = true
allow_dirty = true
[[tool.bumpversion.files]]
filename = "pyproject.toml"
[[tool.bumpversion.files]]
filename = "docs/conf.py"
[tool.pylint.'MESSAGES CONTROL']
disable = """
no-member,
"""
[tool.pylint.typecheck]
generated-members = ["evdev.ecodes.*"]
ignored-modules= ["evdev._*"]
================================================
FILE: requirements-dev.txt
================================================
pytest
Sphinx
sphinx-copybutton ~= 0.5.2
sphinx-rtd-theme
ruff
bump-my-version ~= 0.17.4
build
twine
cibuildwheel
setuptools
================================================
FILE: scripts/build-binary.sh
================================================
#!/usr/bin/env bash
set -o allexport
set -o nounset
CIBW_MANYLINUX_X86_64_IMAGE="manylinux_2_28"
CIBW_MANYLINUX_I686_IMAGE="manylinux_2_28"
CIBW_CONTAINER_ENGINE="podman"
CIBW_SKIP="cp36-*"
CIBW_ARCHS_LINUX="auto64"
CIBW_BEFORE_ALL_LINUX=./scripts/cibw-before.sh
CIBW_TEST_COMMAND="python -c 'import evdev; print(evdev)'"
CIBW_ENVIRONMENT="PACKAGE_NAME=evdev-binary"
exec cibuildwheel
================================================
FILE: scripts/cibw-before.sh
================================================
#!/usr/bin/env bash
if [ -n "$PACKAGE_NAME" ]; then
sed -i -re 's,^(name = ")evdev("),\1'${PACKAGE_NAME}'\2,' pyproject.toml
fi
================================================
FILE: setup.py
================================================
import os
import sys
import shutil
import textwrap
import platform
from pathlib import Path
from subprocess import run
from setuptools import setup, Extension, Command
from setuptools.command import build_ext as _build_ext
curdir = Path(__file__).resolve().parent
ecodes_c_path = curdir / "src/evdev/ecodes.c"
def create_ecodes(headers=None, reproducible=False):
if not headers:
include_paths = set()
cpath = os.environ.get("CPATH", "").strip()
c_inc_path = os.environ.get("C_INCLUDE_PATH", "").strip()
if cpath:
include_paths.update(cpath.split(":"))
if c_inc_path:
include_paths.update(c_inc_path.split(":"))
include_paths.add("/usr/include")
if platform.system().lower() == "freebsd":
files = ["dev/evdev/input.h", "dev/evdev/input-event-codes.h", "dev/evdev/uinput.h"]
else:
files = ["linux/input.h", "linux/input-event-codes.h", "linux/uinput.h"]
headers = [os.path.join(path, file) for path in include_paths for file in files]
headers = [header for header in headers if os.path.isfile(header)]
if not headers:
msg = """\
The 'linux/input.h' and 'linux/input-event-codes.h' include files
are missing. You will have to install the kernel header files in
order to continue:
dnf install kernel-headers-$(uname -r)
apt-get install linux-headers-$(uname -r)
emerge sys-kernel/linux-headers
pacman -S kernel-headers
In case they are installed in a non-standard location, you may use
the '--evdev-headers' option to specify one or more colon-separated
paths. For example:
python setup.py \\
build \\
build_ecodes --evdev-headers path/input.h:path/input-event-codes.h \\
build_ext --include-dirs path/ \\
install
If you want to avoid building this package from source, then please consider
installing the `evdev-binary` package instead. Keep in mind that it may not be
fully compatible with, or support all the features of your current kernel.
"""
sys.stderr.write(textwrap.dedent(msg))
sys.exit(1)
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"]
if reproducible:
cmd.append("--reproducible")
cmd.extend(["--ecodes", *headers])
run(cmd, check=True, stdout=fh)
class build_ecodes(Command):
description = "generate ecodes.c"
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, reproducible=self.reproducible)
class build_ext(_build_ext.build_ext):
def has_ecodes(self):
if ecodes_c_path.exists():
print("ecodes.c already exists ... skipping build_ecodes")
return False
return True
def generate_ecodes_py(self):
ecodes_py = Path(self.build_lib) / "evdev/ecodes.py"
print(f"writing {ecodes_py}")
with ecodes_py.open("w") as fh:
cmd = [sys.executable, "-B", "src/evdev/genecodes_py.py"]
res = run(cmd, env={"PYTHONPATH": self.build_lib}, stdout=fh)
if res.returncode != 0:
print(f"failed to generate static {ecodes_py} - will use ecodes_runtime.py")
shutil.copy("src/evdev/ecodes_runtime.py", ecodes_py)
def run(self):
for cmd_name in self.get_sub_commands():
self.run_command(cmd_name)
_build_ext.build_ext.run(self)
self.generate_ecodes_py()
sub_commands = [("build_ecodes", has_ecodes)] + _build_ext.build_ext.sub_commands
cflags = ["-std=c99", "-Wno-error=declaration-after-statement"]
setup(
ext_modules=[
Extension("evdev._input", sources=["src/evdev/input.c"], extra_compile_args=cflags),
Extension("evdev._uinput", sources=["src/evdev/uinput.c"], extra_compile_args=cflags),
Extension("evdev._ecodes", sources=["src/evdev/ecodes.c"], extra_compile_args=cflags),
],
cmdclass={
"build_ext": build_ext,
"build_ecodes": build_ecodes,
},
)
================================================
FILE: src/evdev/__init__.py
================================================
# --------------------------------------------------------------------------
# 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,
)
================================================
FILE: src/evdev/device.py
================================================
import contextlib
import os
from typing import Dict, Generic, Iterator, List, Literal, NamedTuple, Tuple, TypeVar, Union, overload
from . import _input, ecodes, util
try:
from .eventio_async import EvdevError, EventIO
except ImportError:
from .eventio import EvdevError, EventIO
_AnyStr = TypeVar("_AnyStr", str, bytes)
class AbsInfo(NamedTuple):
"""Absolute axis information.
A ``namedtuple`` with absolute axis information -
corresponds to the ``input_absinfo`` struct:
Attributes
---------
value
Latest reported value for the axis.
min
Specifies minimum value for the axis.
max
Specifies maximum value for the axis.
fuzz
Specifies fuzz value that is used to filter noise from the
event stream.
flat
Values that are within this value will be discarded by joydev
interface and reported as 0 instead.
resolution
Specifies resolution for the values reported for the axis.
Resolution for main axes (``ABS_X, ABS_Y, ABS_Z``) is reported
in units per millimeter (units/mm), resolution for rotational
axes (``ABS_RX, ABS_RY, ABS_RZ``) is reported in units per
radian.
Note
----
The input core does not clamp reported values to the ``[minimum,
maximum]`` limits, such task is left to userspace.
"""
value: int
min: int
max: int
fuzz: int
flat: int
resolution: int
def __str__(self):
return "value {}, min {}, max {}, fuzz {}, flat {}, res {}".format(*self) # pylint: disable=not-an-iterable
class KbdInfo(NamedTuple):
"""Keyboard repeat rate.
Attributes
----------
delay
Amount of time that a key must be depressed before it will start
to repeat (in milliseconds).
repeat
Keyboard repeat rate in characters per second.
"""
delay: int
repeat: int
def __str__(self):
return "delay {}, repeat {}".format(self.delay, self.repeat)
class DeviceInfo(NamedTuple):
"""
Attributes
----------
bustype
vendor
product
version
"""
bustype: int
vendor: int
product: int
version: int
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, 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[_AnyStr, "os.PathLike[_AnyStr]"]):
"""
Arguments
---------
dev : str|bytes|PathLike
Path to input device
"""
#: Path to input device.
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:
fd = os.open(dev, os.O_RDWR | os.O_NONBLOCK)
except OSError:
fd = os.open(dev, os.O_RDONLY | os.O_NONBLOCK)
#: A non-blocking file descriptor to the device file.
self.fd: int = fd
# Returns (bustype, vendor, product, version, name, phys, capabilities).
info_res = _input.ioctl_devinfo(self.fd)
#: A :class:`DeviceInfo <evdev.device.DeviceInfo>` instance.
self.info = DeviceInfo(*info_res[:4])
#: The name of the event device.
self.name: str = info_res[4]
#: The physical topology of the device.
self.phys: str = info_res[5]
#: The unique identifier of the device.
self.uniq: str = info_res[6]
#: The evdev protocol version.
self.version: int = _input.ioctl_EVIOCGVERSION(self.fd)
#: The raw dictionary of device capabilities - see `:func:capabilities()`.
self._rawcapabilities = _input.ioctl_capabilities(self.fd)
#: 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) -> None:
if hasattr(self, "fd") and self.fd is not None:
try:
self.close()
except (OSError, ImportError, AttributeError):
pass
def _capabilities(self, absinfo: bool = True):
res = {}
for etype, _ecodes in self._rawcapabilities.items():
for code in _ecodes:
l = res.setdefault(etype, [])
if isinstance(code, tuple):
if absinfo:
a = code[1] # (0, 0, 0, 255, 0, 0)
i = AbsInfo(*a)
l.append((code[0], i))
else:
l.append(code[0])
else:
l.append(code)
return res
@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.
Example
--------
>>> device.capabilities()
{ 1: [272, 273, 274],
2: [0, 1, 6, 8] }
If ``verbose`` is ``True``, event codes and types will be resolved
to their names.
::
{ ('EV_KEY', 1): [('BTN_MOUSE', 272),
('BTN_RIGHT', 273),
('BTN_MIDDLE', 273)],
('EV_REL', 2): [('REL_X', 0),
('REL_Y', 1),
('REL_HWHEEL', 6),
('REL_WHEEL', 8)] }
Unknown codes or types will be resolved to ``'?'``.
If ``absinfo`` is ``True``, the list of capabilities will also
include absolute axis information in the form of
:class:`AbsInfo` instances::
{ 3: [ (0, AbsInfo(min=0, max=255, fuzz=0, flat=0)),
(1, AbsInfo(min=0, max=255, fuzz=0, flat=0)) ]}
Combined with ``verbose`` the above becomes::
{ ('EV_ABS', 3): [ (('ABS_X', 0), AbsInfo(min=0, max=255, fuzz=0, flat=0)),
(('ABS_Y', 1), AbsInfo(min=0, max=255, fuzz=0, flat=0)) ]}
"""
if verbose:
return dict(util.resolve_ecodes_dict(self._capabilities(absinfo)))
else:
return self._capabilities(absinfo)
def input_props(self, verbose: bool = False):
"""
Get device properties and quirks.
Example
-------
>>> device.input_props()
[0, 5]
If ``verbose`` is ``True``, input properties are resolved to their
names. Unknown codes are resolved to ``'?'``::
[('INPUT_PROP_POINTER', 0), ('INPUT_PROP_POINTING_STICK', 5)]
"""
props = _input.ioctl_EVIOCGPROP(self.fd)
if verbose:
return util.resolve_ecodes(ecodes.INPUT_PROP, props)
return props
def leds(self, verbose: bool = False):
"""
Return currently set LED keys.
Example
-------
>>> device.leds()
[0, 1, 8, 9]
If ``verbose`` is ``True``, event codes are resolved to their
names. Unknown codes are resolved to ``'?'``::
[('LED_NUML', 0), ('LED_CAPSL', 1), ('LED_MISC', 8), ('LED_MAIL', 9)]
"""
leds = _input.ioctl_EVIOCG_bits(self.fd, ecodes.EV_LED)
if verbose:
return util.resolve_ecodes(ecodes.LED, leds)
return leds
def set_led(self, led_num: int, value: int) -> None:
"""
Set the state of the selected LED.
Example
-------
>>> device.set_led(ecodes.LED_NUML, 1)
"""
self.write(ecodes.EV_LED, led_num, value)
def __eq__(self, other):
"""
Two devices are equal if their :data:`info` attributes are equal.
"""
return isinstance(other, self.__class__) and self.info == other.info and self.path == other.path
def __str__(self) -> str:
msg = 'device {}, name "{}", phys "{}", uniq "{}"'
return msg.format(self.path, self.name, self.phys, self.uniq or "")
def __repr__(self) -> str:
msg = (self.__class__.__name__, self.path)
return "{}({!r})".format(*msg)
def __fspath__(self):
return self.path
def close(self) -> None:
if self.fd > -1:
try:
super().close()
os.close(self.fd)
finally:
self.fd = -1
def grab(self) -> None:
"""
Grab input device using ``EVIOCGRAB`` - other applications will
be unable to receive events until the device is released. Only
one process can hold a ``EVIOCGRAB`` on a device.
Warning
-------
Grabbing an already grabbed device will raise an ``OSError``.
"""
_input.ioctl_EVIOCGRAB(self.fd, 1)
def ungrab(self) -> None:
"""
Release device if it has been already grabbed (uses `EVIOCGRAB`).
Warning
-------
Releasing an already released device will raise an
``OSError('Invalid argument')``.
"""
_input.ioctl_EVIOCGRAB(self.fd, 0)
@contextlib.contextmanager
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.
"""
self.grab()
yield
self.ungrab()
def upload_effect(self, effect: "ff.Effect"):
"""
Upload a force feedback effect to a force feedback device.
"""
data = memoryview(effect).tobytes()
ff_id = _input.upload_effect(self.fd, data)
return ff_id
def erase_effect(self, ff_id) -> None:
"""
Erase a force effect from a force feedback device. This also
stops the effect.
"""
_input.erase_effect(self.fd, ff_id)
@property
def repeat(self):
"""
Get or set the keyboard repeat rate (in characters per
minute) and delay (in milliseconds).
"""
return KbdInfo(*_input.ioctl_EVIOCGREP(self.fd))
@repeat.setter
def repeat(self, value: Tuple[int, int]):
return _input.ioctl_EVIOCSREP(self.fd, *value)
def active_keys(self, verbose: bool = False):
"""
Return currently active keys.
Example
-------
>>> device.active_keys()
[1, 42]
If ``verbose`` is ``True``, key codes are resolved to their
verbose names. Unknown codes are resolved to ``'?'``. For
example::
[('KEY_ESC', 1), ('KEY_LEFTSHIFT', 42)]
"""
active_keys = _input.ioctl_EVIOCG_bits(self.fd, ecodes.EV_KEY)
if verbose:
return util.resolve_ecodes(ecodes.KEY, active_keys)
return active_keys
def absinfo(self, axis_num: int):
"""
Return current :class:`AbsInfo` for input device axis
Arguments
---------
axis_num : int
EV_ABS keycode (example :attr:`ecodes.ABS_X`)
Example
-------
>>> device.absinfo(ecodes.ABS_X)
AbsInfo(value=1501, min=-32768, max=32767, fuzz=0, flat=128, resolution=0)
"""
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) -> None:
"""
Update :class:`AbsInfo` values. Only specified values will be overwritten.
Arguments
---------
axis_num : int
EV_ABS keycode (example :attr:`ecodes.ABS_X`)
Example
-------
>>> device.set_absinfo(ecodes.ABS_X, min=-2000, max=2000)
You can also unpack AbsInfo tuple that will overwrite all values
>>> device.set_absinfo(ecodes.ABS_Y, *AbsInfo(0, -2000, 2000, 0, 15, 0))
"""
cur_absinfo = self.absinfo(axis_num)
new_absinfo = AbsInfo(
value if value is not None else cur_absinfo.value,
min if min is not None else cur_absinfo.min,
max if max is not None else cur_absinfo.max,
fuzz if fuzz is not None else cur_absinfo.fuzz,
flat if flat is not None else cur_absinfo.flat,
resolution if resolution is not None else cur_absinfo.resolution,
)
_input.ioctl_EVIOCSABS(self.fd, axis_num, new_absinfo)
================================================
FILE: src/evdev/ecodes.py
================================================
# When installed, this module is replaced by an ecodes.py generated at
# build time by genecodes_py.py (see build_ext in setup.py).
# This stub exists to make development of evdev itself more convenient.
from .ecodes_runtime import *
================================================
FILE: src/evdev/ecodes_runtime.py
================================================
# pylint: disable=undefined-variable
"""
This modules exposes the integer constants defined in ``linux/input.h`` and
``linux/input-event-codes.h``.
Exposed constants::
KEY, ABS, REL, SW, MSC, LED, BTN, REP, SND, ID, EV,
BUS, SYN, FF, FF_STATUS, INPUT_PROP
This module also provides reverse and forward mappings of the names and values
of the above mentioned constants::
>>> evdev.ecodes.KEY_A
30
>>> evdev.ecodes.ecodes['KEY_A']
30
>>> evdev.ecodes.KEY[30]
'KEY_A'
>>> evdev.ecodes.REL[0]
'REL_X'
>>> evdev.ecodes.EV[evdev.ecodes.EV_KEY]
'EV_KEY'
>>> evdev.ecodes.bytype[evdev.ecodes.EV_REL][0]
'REL_X'
Keep in mind that values in reverse mappings may point to one or more event
codes. For example::
>>> evdev.ecodes.FF[80]
('FF_EFFECT_MIN', 'FF_RUMBLE')
>>> evdev.ecodes.FF[81]
'FF_PERIODIC'
"""
from inspect import getmembers
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 UI_FF".split()
prev_prefix = ""
g = globals()
# eg. code: 'REL_Z', val: 2
for code, val in getmembers(_ecodes):
for prefix in prefixes: # eg. 'REL'
if code.startswith(prefix):
ecodes[code] = val
# FF_STATUS codes should not appear in the FF reverse mapping
if not code.startswith(prev_prefix):
d = g.setdefault(prefix, {})
# codes that share the same value will be added to a list. eg:
# >>> ecodes.FF_STATUS
# {0: 'FF_STATUS_STOPPED', 1: ['FF_STATUS_MAX', 'FF_STATUS_PLAYING']}
if val in d:
if isinstance(d[val], list):
d[val].append(code)
else:
d[val] = [d[val], code]
else:
d[val] = code
prev_prefix = prefix
# Convert lists to tuples.
k, v = None, None
for prefix in prefixes:
for k, v in g[prefix].items():
if isinstance(v, list):
g[prefix][k] = tuple(v)
#: Keys are a combination of all BTN and KEY codes.
keys = {}
keys.update(BTN)
keys.update(KEY)
# make keys safe to use for the default list of uinput device
# capabilities
del keys[_ecodes.KEY_MAX]
del keys[_ecodes.KEY_CNT]
#: Mapping of event types to other value/name mappings.
bytype = {
_ecodes.EV_KEY: keys,
_ecodes.EV_ABS: ABS,
_ecodes.EV_REL: REL,
_ecodes.EV_SW: SW,
_ecodes.EV_MSC: MSC,
_ecodes.EV_LED: LED,
_ecodes.EV_REP: REP,
_ecodes.EV_SND: SND,
_ecodes.EV_SYN: SYN,
_ecodes.EV_FF: FF,
_ecodes.EV_FF_STATUS: FF_STATUS,
}
from evdev._ecodes import *
# cheaper than whitelisting in an __all__
del code, val, prefix, getmembers, g, d, k, v, prefixes, prev_prefix
================================================
FILE: src/evdev/eventio.py
================================================
import fcntl
import functools
import os
import select
from typing import Iterator, Union
from . import _input, _uinput, ecodes
from .events import InputEvent
# --------------------------------------------------------------------------
class EvdevError(Exception):
pass
class EventIO:
"""
Base class for reading and writing input events.
This class is used by :class:`InputDevice` and :class:`UInput`.
- On, :class:`InputDevice` it used for reading user-generated events (e.g.
key presses, mouse movements) and writing feedback events (e.g. leds,
beeps).
- On, :class:`UInput` it used for writing user-generated events (e.g.
key presses, mouse movements) and reading feedback events (e.g. leds,
beeps).
"""
def fileno(self):
"""
Return the file descriptor to the open event device. This makes
it possible to pass instances directly to :func:`select.select()` and
:class:`asyncore.file_dispatcher`.
"""
return self.fd
def read_loop(self) -> Iterator[InputEvent]:
"""
Enter an endless :func:`select.select()` loop that yields input events.
"""
while True:
r, w, x = select.select([self.fd], [], [])
for event in self.read():
yield event
def read_one(self) -> Union[InputEvent, None]:
"""
Read and return a single input event as an instance of
:class:`InputEvent <evdev.events.InputEvent>`.
Return ``None`` if there are no pending input events.
"""
# event -> (sec, usec, type, code, val)
event = _input.device_read(self.fd)
if event:
return InputEvent(*event)
def read(self) -> Iterator[InputEvent]:
"""
Read multiple input events from device. Return a generator object that
yields :class:`InputEvent <evdev.events.InputEvent>` instances. Raises
`BlockingIOError` if there are no available events at the moment.
"""
# events -> ((sec, usec, type, code, val), ...)
events = _input.device_read_many(self.fd)
for event in events:
yield InputEvent(*event)
# pylint: disable=no-self-argument
def need_write(func):
"""
Decorator that raises :class:`EvdevError` if there is no write access to the
input device.
"""
@functools.wraps(func)
def wrapper(*args):
fd = args[0].fd
if fcntl.fcntl(fd, fcntl.F_GETFL) & os.O_RDWR:
# pylint: disable=not-callable
return func(*args)
msg = 'no write access to device "%s"' % args[0].path
raise EvdevError(msg)
return wrapper
def write_event(self, event):
"""
Inject an input event into the input subsystem. Events are
queued until a synchronization event is received.
Arguments
---------
event: InputEvent
InputEvent instance or an object with an ``event`` attribute
(:class:`KeyEvent <evdev.events.KeyEvent>`, :class:`RelEvent
<evdev.events.RelEvent>` etc).
Example
-------
>>> ev = InputEvent(1334414993, 274296, ecodes.EV_KEY, ecodes.KEY_A, 1)
>>> ui.write_event(ev)
"""
if hasattr(event, "event"):
event = event.event
self.write(event.type, event.code, event.value)
@need_write
def write(self, etype: int, code: int, value: int):
"""
Inject an input event into the input subsystem. Events are
queued until a synchronization event is received.
Arguments
---------
etype
event type (e.g. ``EV_KEY``).
code
event code (e.g. ``KEY_A``).
value
event value (e.g. 0 1 2 - depends on event type).
Example
---------
>>> ui.write(e.EV_KEY, e.KEY_A, 1) # key A - down
>>> ui.write(e.EV_KEY, e.KEY_A, 0) # key A - up
"""
_uinput.write(self.fd, etype, code, value)
def syn(self):
"""
Inject a ``SYN_REPORT`` event into the input subsystem. Events
queued by :func:`write()` will be fired. If possible, events
will be merged into an 'atomic' event.
"""
self.write(ecodes.EV_SYN, ecodes.SYN_REPORT, 0)
def close(self):
pass
================================================
FILE: src/evdev/eventio_async.py
================================================
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):
loop = asyncio.get_event_loop()
def ready():
loop.remove_reader(self.fileno())
callback()
loop.add_reader(self.fileno(), ready)
def _set_result(self, future, cb):
try:
future.set_result(cb())
except Exception as error:
future.set_exception(error)
def async_read_one(self):
"""
Asyncio coroutine to read and return a single input event as
an instance of :class:`InputEvent <evdev.events.InputEvent>`.
"""
future = asyncio.Future()
self._do_when_readable(lambda: self._set_result(future, self.read_one))
return future
def async_read(self):
"""
Asyncio coroutine to read multiple input events from device. Return
a generator object that yields :class:`InputEvent <evdev.events.InputEvent>`
instances.
"""
future = asyncio.Future()
self._do_when_readable(lambda: self._set_result(future, self.read))
return future
def async_read_loop(self) -> ReadIterator:
"""
Return an iterator that yields input events. This iterator is
compatible with the ``async for`` syntax.
"""
return ReadIterator(self)
def close(self):
try:
loop = asyncio.get_event_loop()
loop.remove_reader(self.fileno())
except RuntimeError:
# no event loop present, so there is nothing to
# remove the reader from. Ignore
pass
================================================
FILE: src/evdev/events.py
================================================
"""
This module provides the :class:`InputEvent` class, which closely
resembles the ``input_event`` struct defined in ``linux/input.h``:
.. code-block:: c
struct input_event {
struct timeval time;
__u16 type;
__u16 code;
__s32 value;
};
This module also defines several :class:`InputEvent` sub-classes that
know more about the different types of events (key, abs, rel etc). The
:data:`event_factory` dictionary maps event types to these classes.
Assuming you use the :func:`evdev.util.categorize()` function to
categorize events according to their type, adding or replacing a class
for a specific event type becomes a matter of modifying
:data:`event_factory`.
All classes in this module have reasonable ``str()`` and ``repr()``
methods::
>>> print(event)
event at 1337197425.477827, code 04, type 04, val 458792
>>> print(repr(event))
InputEvent(1337197425L, 477827L, 4, 4, 458792L)
>>> print(key_event)
key event at 1337197425.477835, 28 (KEY_ENTER), up
>>> print(repr(key_event))
KeyEvent(InputEvent(1337197425L, 477835L, 1, 28, 0L))
"""
# event type descriptions have been taken mot-a-mot from:
# http://www.kernel.org/doc/Documentation/input/event-codes.txt
# pylint: disable=no-name-in-module
from typing import Final
from .ecodes import ABS, EV_ABS, EV_KEY, EV_REL, EV_SYN, KEY, REL, SYN, keys
class InputEvent:
"""A generic input event."""
__slots__ = "sec", "usec", "type", "code", "value"
def __init__(self, sec, usec, type, code, value):
#: Time in seconds since epoch at which event occurred.
self.sec: int = sec
#: Microsecond portion of the timestamp.
self.usec: int = usec
#: Event type - one of ``ecodes.EV_*``.
self.type: int = type
#: Event code related to the event type.
self.code: int = code
#: Event value related to the event type.
self.value: int = value
def timestamp(self) -> float:
"""Return event timestamp as a float."""
return self.sec + (self.usec / 1000000.0)
def __str__(self):
msg = "event at {:f}, code {:02d}, type {:02d}, val {:02d}"
return msg.format(self.timestamp(), self.code, self.type, self.value)
def __repr__(self):
msg = "{}({!r}, {!r}, {!r}, {!r}, {!r})"
return msg.format(self.__class__.__name__, self.sec, self.usec, self.type, self.code, self.value)
class KeyEvent:
"""An event generated by a keyboard, button or other key-like devices."""
key_up: Final[int] = 0x0
key_down: Final[int] = 0x1
key_hold: Final[int] = 0x2
__slots__ = "scancode", "keycode", "keystate", "event"
def __init__(self, event: InputEvent, allow_unknown: bool = False):
"""
The ``allow_unknown`` argument determines what to do in the event of an event code
for which a key code cannot be found. If ``False`` a ``KeyError`` will be raised.
If ``True`` the keycode will be set to the hex value of the event code.
"""
self.scancode: int = event.code
if event.value == 0:
self.keystate = KeyEvent.key_up
elif event.value == 2:
self.keystate = KeyEvent.key_hold
elif event.value == 1:
self.keystate = KeyEvent.key_down
try:
self.keycode = keys[event.code]
except KeyError:
if allow_unknown:
self.keycode = "0x{:02X}".format(event.code)
else:
raise
#: Reference to an :class:`InputEvent` instance.
self.event: InputEvent = event
def __str__(self):
try:
ks = ("up", "down", "hold")[self.keystate]
except IndexError:
ks = "unknown"
msg = "key event at {:f}, {} ({}), {}"
return msg.format(self.event.timestamp(), self.scancode, self.keycode, ks)
def __repr__(self):
return "{}({!r})".format(self.__class__.__name__, self.event)
class RelEvent:
"""A relative axis event (e.g moving the mouse 5 units to the left)."""
__slots__ = "event"
def __init__(self, event: InputEvent):
#: Reference to an :class:`InputEvent` instance.
self.event: InputEvent = event
def __str__(self):
msg = "relative axis event at {:f}, {}"
return msg.format(self.event.timestamp(), REL[self.event.code])
def __repr__(self):
return "{}({!r})".format(self.__class__.__name__, self.event)
class AbsEvent:
"""An absolute axis event (e.g the coordinates of a tap on a touchscreen)."""
__slots__ = "event"
def __init__(self, event: InputEvent):
#: Reference to an :class:`InputEvent` instance.
self.event: InputEvent = event
def __str__(self):
msg = "absolute axis event at {:f}, {}"
return msg.format(self.event.timestamp(), ABS[self.event.code])
def __repr__(self):
return "{}({!r})".format(self.__class__.__name__, self.event)
class SynEvent:
"""
A synchronization event. Used as markers to separate events. Events may be
separated in time or in space, such as with the multitouch protocol.
"""
__slots__ = "event"
def __init__(self, event: InputEvent):
#: Reference to an :class:`InputEvent` instance.
self.event: InputEvent = event
def __str__(self):
msg = "synchronization event at {:f}, {}"
return msg.format(self.event.timestamp(), SYN[self.event.code])
def __repr__(self):
return "{}({!r})".format(self.__class__.__name__, self.event)
#: A mapping of event types to :class:`InputEvent` sub-classes. Used
#: by :func:`evdev.util.categorize()`
event_factory = {
EV_KEY: KeyEvent,
EV_REL: RelEvent,
EV_ABS: AbsEvent,
EV_SYN: SynEvent,
}
__all__ = ("InputEvent", "KeyEvent", "RelEvent", "SynEvent", "AbsEvent", "event_factory")
================================================
FILE: src/evdev/evtest.py
================================================
"""
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)
================================================
FILE: src/evdev/ff.py
================================================
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,
# }
================================================
FILE: src/evdev/genecodes_c.py
================================================
"""
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())
================================================
FILE: src/evdev/genecodes_py.py
================================================
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()
================================================
FILE: src/evdev/input.c
================================================
/*
* Python bindings to certain linux input subsystem functions.
*
* While everything here can be implemented in pure Python with struct and
* fcntl.ioctl, imho, it is much more straightforward to do so in C.
*
*/
#include <Python.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#ifdef __FreeBSD__
#include <dev/evdev/input.h>
#else
#include <linux/input.h>
#endif
#ifndef input_event_sec
#define input_event_sec time.tv_sec
#define input_event_usec time.tv_usec
#endif
#define MAX_NAME_SIZE 256
extern char* EV_NAME[EV_CNT];
extern int EV_TYPE_MAX[EV_CNT];
extern char** EV_TYPE_NAME[EV_CNT];
extern char* BUS_NAME[];
int test_bit(const char* bitmask, int bit) {
return bitmask[bit/8] & (1 << (bit % 8));
}
// Read input event from a device and return a tuple that mimics input_event
static PyObject *
device_read(PyObject *self, PyObject *args)
{
struct input_event event;
// get device file descriptor (O_RDONLY|O_NONBLOCK)
int fd = (int)PyLong_AsLong(PyTuple_GET_ITEM(args, 0));
int n = read(fd, &event, sizeof(event));
if (n < 0) {
if (errno == EAGAIN) {
Py_INCREF(Py_None);
return Py_None;
}
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
PyObject *py_input_event = PyTuple_New(5);
PyTuple_SET_ITEM(py_input_event, 0, PyLong_FromLong(event.input_event_sec));
PyTuple_SET_ITEM(py_input_event, 1, PyLong_FromLong(event.input_event_usec));
PyTuple_SET_ITEM(py_input_event, 2, PyLong_FromLong(event.type));
PyTuple_SET_ITEM(py_input_event, 3, PyLong_FromLong(event.code));
PyTuple_SET_ITEM(py_input_event, 4, PyLong_FromLong(event.value));
return py_input_event;
}
// Read multiple input events from a device and return a list of tuples
static PyObject *
device_read_many(PyObject *self, PyObject *args)
{
// get device file descriptor (O_RDONLY|O_NONBLOCK)
int fd = (int)PyLong_AsLong(PyTuple_GET_ITEM(args, 0));
struct input_event event[64];
size_t event_size = sizeof(struct input_event);
ssize_t nread = read(fd, event, event_size*64);
if (nread < 0) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
// Construct a tuple of event tuples. Each tuple is the arguments to InputEvent.
size_t num_events = nread / event_size;
PyObject* events = PyTuple_New(num_events);
for (size_t i = 0 ; i < num_events; i++) {
PyObject *py_input_event = PyTuple_New(5);
PyTuple_SET_ITEM(py_input_event, 0, PyLong_FromLong(event[i].input_event_sec));
PyTuple_SET_ITEM(py_input_event, 1, PyLong_FromLong(event[i].input_event_usec));
PyTuple_SET_ITEM(py_input_event, 2, PyLong_FromLong(event[i].type));
PyTuple_SET_ITEM(py_input_event, 3, PyLong_FromLong(event[i].code));
PyTuple_SET_ITEM(py_input_event, 4, PyLong_FromLong(event[i].value));
PyTuple_SET_ITEM(events, i, py_input_event);
}
return events;
}
// Get the event types and event codes that the input device supports
static PyObject *
ioctl_capabilities(PyObject *self, PyObject *args)
{
int fd, ev_type, ev_code;
char ev_bits[EV_MAX/8 + 1], code_bits[KEY_MAX/8 + 1];
struct input_absinfo absinfo;
int ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
// @todo: figure out why fd gets zeroed on an ioctl after the
// refactoring and get rid of this workaround
const int _fd = fd;
// Capabilities is a mapping of supported event types to lists of handled
// events e.g: {1: [272, 273, 274, 275], 2: [0, 1, 6, 8]}
PyObject* capabilities = PyDict_New();
PyObject* eventcodes = NULL;
PyObject* evlong = NULL;
PyObject* capability = NULL;
PyObject* py_absinfo = NULL;
PyObject* absitem = NULL;
memset(&ev_bits, 0, sizeof(ev_bits));
if (ioctl(_fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) < 0)
goto on_err;
// Build a dictionary of the device's capabilities
for (ev_type=0 ; ev_type<EV_MAX ; ev_type++) {
if (test_bit(ev_bits, ev_type)) {
capability = PyLong_FromLong(ev_type);
eventcodes = PyList_New(0);
memset(&code_bits, 0, sizeof(code_bits));
ioctl(_fd, EVIOCGBIT(ev_type, sizeof(code_bits)), code_bits);
for (ev_code = 0; ev_code < KEY_MAX; ev_code++) {
if (test_bit(code_bits, ev_code)) {
// Get abs{min,max,fuzz,flat} values for ABS_* event codes
if (ev_type == EV_ABS) {
memset(&absinfo, 0, sizeof(absinfo));
ioctl(_fd, EVIOCGABS(ev_code), &absinfo);
py_absinfo = Py_BuildValue("(iiiiii)",
absinfo.value,
absinfo.minimum,
absinfo.maximum,
absinfo.fuzz,
absinfo.flat,
absinfo.resolution);
evlong = PyLong_FromLong(ev_code);
absitem = Py_BuildValue("(OO)", evlong, py_absinfo);
// absitem -> tuple(ABS_X, (0, 255, 0, 0))
PyList_Append(eventcodes, absitem);
Py_DECREF(absitem);
Py_DECREF(py_absinfo);
}
else {
evlong = PyLong_FromLong(ev_code);
PyList_Append(eventcodes, evlong);
}
Py_DECREF(evlong);
}
}
// capabilities[EV_KEY] = [KEY_A, KEY_B, KEY_C, ...]
// capabilities[EV_ABS] = [(ABS_X, (0, 255, 0, 0)), ...]
PyDict_SetItem(capabilities, capability, eventcodes);
Py_DECREF(capability);
Py_DECREF(eventcodes);
}
}
return capabilities;
on_err:
Py_XDECREF(capabilities);
Py_XDECREF(eventcodes);
Py_XDECREF(capability);
Py_XDECREF(py_absinfo);
Py_XDECREF(absitem);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
// An all-in-one function for describing an input device
static PyObject *
ioctl_devinfo(PyObject *self, PyObject *args)
{
int fd;
struct input_id iid;
char name[MAX_NAME_SIZE];
char phys[MAX_NAME_SIZE] = {0};
char uniq[MAX_NAME_SIZE] = {0};
int ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
memset(&iid, 0, sizeof(iid));
if (ioctl(fd, EVIOCGID, &iid) < 0) goto on_err;
if (ioctl(fd, EVIOCGNAME(sizeof(name)), name) < 0) goto on_err;
// Some devices do not have a physical topology associated with them
ioctl(fd, EVIOCGPHYS(sizeof(phys)), phys);
// Some kernels have started reporting bluetooth controller MACs as phys.
// This lets us get the real physical address. As with phys, it may be blank.
ioctl(fd, EVIOCGUNIQ(sizeof(uniq)), uniq);
return Py_BuildValue("hhhhsss", iid.bustype, iid.vendor, iid.product, iid.version,
name, phys, uniq);
on_err:
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
static PyObject *
ioctl_EVIOCGABS(PyObject *self, PyObject *args)
{
int fd, ev_code;
struct input_absinfo absinfo;
PyObject* py_absinfo = NULL;
int ret = PyArg_ParseTuple(args, "ii", &fd, &ev_code);
if (!ret) return NULL;
memset(&absinfo, 0, sizeof(absinfo));
ret = ioctl(fd, EVIOCGABS(ev_code), &absinfo);
if (ret == -1) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
py_absinfo = Py_BuildValue("(iiiiii)",
absinfo.value,
absinfo.minimum,
absinfo.maximum,
absinfo.fuzz,
absinfo.flat,
absinfo.resolution);
return py_absinfo;
}
static PyObject *
ioctl_EVIOCSABS(PyObject *self, PyObject *args)
{
int fd, ev_code;
struct input_absinfo absinfo;
int ret = PyArg_ParseTuple(args,
"ii(iiiiii)",
&fd,
&ev_code,
&absinfo.value,
&absinfo.minimum,
&absinfo.maximum,
&absinfo.fuzz,
&absinfo.flat,
&absinfo.resolution);
if (!ret) return NULL;
ret = ioctl(fd, EVIOCSABS(ev_code), &absinfo);
if (ret == -1) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
ioctl_EVIOCGREP(PyObject *self, PyObject *args)
{
int fd, ret;
unsigned int rep[REP_CNT] = {0};
ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
ret = ioctl(fd, EVIOCGREP, &rep);
if (ret == -1)
return NULL;
return Py_BuildValue("(ii)", rep[REP_DELAY], rep[REP_PERIOD]);
}
static PyObject *
ioctl_EVIOCSREP(PyObject *self, PyObject *args)
{
int fd, ret;
unsigned int rep[REP_CNT] = {0};
ret = PyArg_ParseTuple(args, "iii", &fd, &rep[0], &rep[1]);
if (!ret) return NULL;
ret = ioctl(fd, EVIOCSREP, &rep);
if (ret == -1)
return NULL;
return Py_BuildValue("i", ret);
}
static PyObject *
ioctl_EVIOCGVERSION(PyObject *self, PyObject *args)
{
int fd, ret, res;
ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
ret = ioctl(fd, EVIOCGVERSION, &res);
if (ret == -1)
return NULL;
return Py_BuildValue("i", res);
}
static PyObject *
ioctl_EVIOCGRAB(PyObject *self, PyObject *args)
{
int fd, ret, flag;
ret = PyArg_ParseTuple(args, "ii", &fd, &flag);
if (!ret) return NULL;
ret = ioctl(fd, EVIOCGRAB, (intptr_t)flag);
if (ret != 0) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
ioctl_EVIOCG_bits(PyObject *self, PyObject *args)
{
int max, fd, evtype, ret;
ret = PyArg_ParseTuple(args, "ii", &fd, &evtype);
if (!ret) return NULL;
switch (evtype) {
case EV_LED:
max = LED_MAX; break;
case EV_SND:
max = SND_MAX; break;
case EV_KEY:
max = KEY_MAX; break;
case EV_SW:
max = SW_MAX; break;
default:
return NULL;
}
char bytes[(max+7)/8];
memset(bytes, 0, sizeof bytes);
switch (evtype) {
case EV_LED:
ret = ioctl(fd, EVIOCGLED(sizeof(bytes)), &bytes);
break;
case EV_SND:
ret = ioctl(fd, EVIOCGSND(sizeof(bytes)), &bytes);
break;
case EV_KEY:
ret = ioctl(fd, EVIOCGKEY(sizeof(bytes)), &bytes);
break;
case EV_SW:
ret = ioctl(fd, EVIOCGSW(sizeof(bytes)), &bytes);
break;
}
if (ret == -1)
return NULL;
PyObject* res = PyList_New(0);
for (int i=0; i<=max; i++) {
if (test_bit(bytes, i)) {
PyObject *val = PyLong_FromLong(i);
PyList_Append(res, val);
Py_DECREF(val);
}
}
return res;
}
static PyObject *
ioctl_EVIOCGEFFECTS(PyObject *self, PyObject *args)
{
int fd, ret, res;
ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
ret = ioctl(fd, EVIOCGEFFECTS, &res);
if (ret == -1)
return NULL;
return Py_BuildValue("i", res);
}
void print_ff_effect(struct ff_effect* effect) {
fprintf(stderr,
"ff_effect:\n"
" type: %d \n"
" id: %d \n"
" direction: %d\n"
" trigger: (%d, %d)\n"
" replay: (%d, %d)\n",
effect->type, effect->id, effect->direction,
effect->trigger.button, effect->trigger.interval,
effect->replay.length, effect->replay.delay
);
switch (effect->type) {
case FF_CONSTANT:
fprintf(stderr, " constant: (%d, (%d, %d, %d, %d))\n", effect->u.constant.level,
effect->u.constant.envelope.attack_length,
effect->u.constant.envelope.attack_level,
effect->u.constant.envelope.fade_length,
effect->u.constant.envelope.fade_level);
break;
case FF_RUMBLE:
fprintf(stderr, " rumble: (%d, %d)\n",
effect->u.rumble.strong_magnitude,
effect->u.rumble.weak_magnitude);
break;
}
}
static PyObject *
upload_effect(PyObject *self, PyObject *args)
{
int fd, ret;
PyObject* effect_data;
ret = PyArg_ParseTuple(args, "iO", &fd, &effect_data);
if (!ret) return NULL;
void* data = PyBytes_AsString(effect_data);
struct ff_effect effect = {};
memmove(&effect, data, sizeof(struct ff_effect));
// print_ff_effect(&effect);
ret = ioctl(fd, EVIOCSFF, &effect);
if (ret != 0) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
return Py_BuildValue("i", effect.id);
}
static PyObject *
erase_effect(PyObject *self, PyObject *args)
{
int fd, ret;
PyObject* ff_id_obj;
ret = PyArg_ParseTuple(args, "iO", &fd, &ff_id_obj);
if (!ret) return NULL;
long ff_id = PyLong_AsLong(ff_id_obj);
ret = ioctl(fd, EVIOCRMFF, ff_id);
if (ret != 0) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
ioctl_EVIOCGPROP(PyObject *self, PyObject *args)
{
int fd, ret;
ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
char bytes[(INPUT_PROP_MAX+7)/8];
memset(bytes, 0, sizeof bytes);
ret = ioctl(fd, EVIOCGPROP(sizeof(bytes)), &bytes);
if (ret == -1)
return NULL;
PyObject* res = PyList_New(0);
for (int i=0; i<INPUT_PROP_MAX; i++) {
if (test_bit(bytes, i)) {
PyObject *val = PyLong_FromLong(i);
PyList_Append(res, val);
Py_DECREF(val);
}
}
return res;
}
static PyMethodDef MethodTable[] = {
{ "ioctl_devinfo", ioctl_devinfo, METH_VARARGS, "fetch input device info" },
{ "ioctl_capabilities", ioctl_capabilities, METH_VARARGS, "fetch input device capabilities" },
{ "ioctl_EVIOCGABS", ioctl_EVIOCGABS, METH_VARARGS, "get input device absinfo"},
{ "ioctl_EVIOCSABS", ioctl_EVIOCSABS, METH_VARARGS, "set input device absinfo"},
{ "ioctl_EVIOCGREP", ioctl_EVIOCGREP, METH_VARARGS},
{ "ioctl_EVIOCSREP", ioctl_EVIOCSREP, METH_VARARGS},
{ "ioctl_EVIOCGVERSION", ioctl_EVIOCGVERSION, METH_VARARGS},
{ "ioctl_EVIOCGRAB", ioctl_EVIOCGRAB, METH_VARARGS},
{ "ioctl_EVIOCGEFFECTS", ioctl_EVIOCGEFFECTS, METH_VARARGS, "fetch the number of effects the device can keep in its memory." },
{ "ioctl_EVIOCG_bits", ioctl_EVIOCG_bits, METH_VARARGS, "get state of KEY|LED|SND|SW"},
{ "ioctl_EVIOCGPROP", ioctl_EVIOCGPROP, METH_VARARGS, "get device properties"},
{ "device_read", device_read, METH_VARARGS, "read an input event from a device" },
{ "device_read_many", device_read_many, METH_VARARGS, "read all available input events from a device" },
{ "upload_effect", upload_effect, METH_VARARGS, "" },
{ "erase_effect", erase_effect, METH_VARARGS, "" },
{ NULL, NULL, 0, NULL}
};
static struct PyModuleDef moduledef = {
PyModuleDef_HEAD_INIT,
"_input",
"Python bindings to certain linux input subsystem functions",
-1, /* m_size */
MethodTable, /* m_methods */
NULL, /* m_reload */
NULL, /* m_traverse */
NULL, /* m_clear */
NULL, /* m_free */
};
static PyObject *
moduleinit(void)
{
PyObject* m = PyModule_Create(&moduledef);
if (m == NULL) return NULL;
return m;
}
PyMODINIT_FUNC
PyInit__input(void)
{
return moduleinit();
}
================================================
FILE: src/evdev/py.typed
================================================
================================================
FILE: src/evdev/uinput.c
================================================
#include <Python.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#ifdef __FreeBSD__
#include <dev/evdev/input.h>
#include <dev/evdev/uinput.h>
#else
#include <linux/input.h>
#include <linux/uinput.h>
#endif
#ifndef input_event_sec
#define input_event_sec time.tv_sec
#define input_event_usec time.tv_usec
#endif
// Workaround for installing on kernels newer than 4.4.
#ifndef FF_MAX_EFFECTS
#define FF_MAX_EFFECTS FF_GAIN;
#endif
int _uinput_close(int fd)
{
if (ioctl(fd, UI_DEV_DESTROY) < 0) {
int oerrno = errno;
close(fd);
errno = oerrno;
return -1;
}
return close(fd);
}
static PyObject *
uinput_open(PyObject *self, PyObject *args)
{
const char* devnode;
int ret = PyArg_ParseTuple(args, "s", &devnode);
if (!ret) return NULL;
int fd = open(devnode, O_RDWR | O_NONBLOCK);
if (fd < 0) {
PyErr_SetString(PyExc_OSError, "could not open uinput device in write mode");
return NULL;
}
return Py_BuildValue("i", fd);
}
static PyObject *
uinput_set_phys(PyObject *self, PyObject *args)
{
int fd;
const char* phys;
int ret = PyArg_ParseTuple(args, "is", &fd, &phys);
if (!ret) return NULL;
if (ioctl(fd, UI_SET_PHYS, phys) < 0)
goto on_err;
Py_RETURN_NONE;
on_err:
_uinput_close(fd);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
static PyObject *
uinput_set_prop(PyObject *self, PyObject *args)
{
int fd;
uint16_t prop;
int ret = PyArg_ParseTuple(args, "ih", &fd, &prop);
if (!ret) return NULL;
if (ioctl(fd, UI_SET_PROPBIT, prop) < 0)
goto on_err;
Py_RETURN_NONE;
on_err:
_uinput_close(fd);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
static PyObject *
uinput_get_sysname(PyObject *self, PyObject *args)
{
int fd;
char sysname[64];
int ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
#ifdef UI_GET_SYSNAME
if (ioctl(fd, UI_GET_SYSNAME(sizeof(sysname)), &sysname) < 0)
goto on_err;
return Py_BuildValue("s", &sysname);
#endif
on_err:
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
// Different kernel versions have different device setup methods. You can read
// more about it here:
// https://github.com/torvalds/linux/commit/052876f8e5aec887d22c4d06e54aa5531ffcec75
// Setup function for kernel >= v4.5
#if defined(UI_DEV_SETUP) && defined(UI_ABS_SETUP)
static PyObject *
uinput_setup(PyObject *self, PyObject *args) {
int fd, len, i;
uint16_t vendor, product, version, bustype;
uint32_t max_effects;
PyObject *absinfo = NULL, *item = NULL;
struct uinput_abs_setup abs_setup;
const char* name;
int ret = PyArg_ParseTuple(args, "isHHHHOI", &fd, &name, &vendor,
&product, &version, &bustype, &absinfo, &max_effects);
if (!ret) return NULL;
// Setup absinfo:
len = PyList_Size(absinfo);
for (i=0; i<len; i++) {
// item -> (ABS_X, 0, 255, 0, 0, 0, 0)
item = PyList_GetItem(absinfo, i);
memset(&abs_setup, 0, sizeof(abs_setup)); // Clear struct
abs_setup.code = PyLong_AsLong(PyList_GetItem(item, 0));
abs_setup.absinfo.value = PyLong_AsLong(PyList_GetItem(item, 1));
abs_setup.absinfo.minimum = PyLong_AsLong(PyList_GetItem(item, 2));
abs_setup.absinfo.maximum = PyLong_AsLong(PyList_GetItem(item, 3));
abs_setup.absinfo.fuzz = PyLong_AsLong(PyList_GetItem(item, 4));
abs_setup.absinfo.flat = PyLong_AsLong(PyList_GetItem(item, 5));
abs_setup.absinfo.resolution = PyLong_AsLong(PyList_GetItem(item, 6));
if(ioctl(fd, UI_ABS_SETUP, &abs_setup) < 0)
goto on_err;
}
// Setup evdev:
struct uinput_setup usetup;
memset(&usetup, 0, sizeof(usetup));
strncpy(usetup.name, name, sizeof(usetup.name) - 1);
usetup.id.vendor = vendor;
usetup.id.product = product;
usetup.id.version = version;
usetup.id.bustype = bustype;
usetup.ff_effects_max = max_effects;
if(ioctl(fd, UI_DEV_SETUP, &usetup) < 0)
goto on_err;
Py_RETURN_NONE;
on_err:
_uinput_close(fd);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
// Fallback setup function (Linux <= 4.5 and FreeBSD).
#else
static PyObject *
uinput_setup(PyObject *self, PyObject *args) {
int fd, len, i, abscode;
uint16_t vendor, product, version, bustype;
uint32_t max_effects;
PyObject *absinfo = NULL, *item = NULL;
struct uinput_user_dev uidev;
const char* name;
int ret = PyArg_ParseTuple(args, "isHHHHOI", &fd, &name, &vendor,
&product, &version, &bustype, &absinfo, &max_effects);
if (!ret) return NULL;
memset(&uidev, 0, sizeof(uidev));
strncpy(uidev.name, name, sizeof(uidev.name) - 1);
uidev.id.vendor = vendor;
uidev.id.product = product;
uidev.id.version = version;
uidev.id.bustype = bustype;
uidev.ff_effects_max = max_effects;
len = PyList_Size(absinfo);
for (i=0; i<len; i++) {
// item -> (ABS_X, 0, 255, 0, 0, 0, 0)
item = PyList_GetItem(absinfo, i);
abscode = (int)PyLong_AsLong(PyList_GetItem(item, 0));
/* min/max/fuzz/flat start from index 2 because index 1 is value */
uidev.absmin[abscode] = PyLong_AsLong(PyList_GetItem(item, 2));
uidev.absmax[abscode] = PyLong_AsLong(PyList_GetItem(item, 3));
uidev.absfuzz[abscode] = PyLong_AsLong(PyList_GetItem(item, 4));
uidev.absflat[abscode] = PyLong_AsLong(PyList_GetItem(item, 5));
}
if (write(fd, &uidev, sizeof(uidev)) != sizeof(uidev))
goto on_err;
Py_RETURN_NONE;
on_err:
_uinput_close(fd);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
#endif
static PyObject *
uinput_create(PyObject *self, PyObject *args)
{
int fd;
int ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
if (ioctl(fd, UI_DEV_CREATE) < 0)
goto on_err;
Py_RETURN_NONE;
on_err:
_uinput_close(fd);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
static PyObject *
uinput_close(PyObject *self, PyObject *args)
{
int fd;
int ret = PyArg_ParseTuple(args, "i", &fd);
if (!ret) return NULL;
if (_uinput_close(fd) < 0) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
uinput_write(PyObject *self, PyObject *args)
{
int fd, type, code, value;
int ret = PyArg_ParseTuple(args, "iiii", &fd, &type, &code, &value);
if (!ret) return NULL;
struct input_event event;
struct timeval tval;
memset(&event, 0, sizeof(event));
gettimeofday(&tval, 0);
event.input_event_usec = tval.tv_usec;
event.input_event_sec = tval.tv_sec;
event.type = type;
event.code = code;
event.value = value;
if (write(fd, &event, sizeof(event)) != sizeof(event)) {
// @todo: elaborate
// PyErr_SetString(PyExc_OSError, "error writing event to uinput device");
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
uinput_enable_event(PyObject *self, PyObject *args)
{
int fd;
uint16_t type, code;
unsigned long req;
int ret = PyArg_ParseTuple(args, "ihh", &fd, &type, &code);
if (!ret) return NULL;
switch (type) {
case EV_KEY: req = UI_SET_KEYBIT; break;
case EV_ABS: req = UI_SET_ABSBIT; break;
case EV_REL: req = UI_SET_RELBIT; break;
case EV_MSC: req = UI_SET_MSCBIT; break;
case EV_SW: req = UI_SET_SWBIT; break;
case EV_LED: req = UI_SET_LEDBIT; break;
case EV_FF: req = UI_SET_FFBIT; break;
case EV_SND: req = UI_SET_SNDBIT; break;
default:
errno = EINVAL;
goto on_err;
}
if (ioctl(fd, UI_SET_EVBIT, type) < 0)
goto on_err;
if (ioctl(fd, req, code) < 0)
goto on_err;
Py_RETURN_NONE;
on_err:
_uinput_close(fd);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
int _uinput_begin_upload(int fd, struct uinput_ff_upload *upload)
{
return ioctl(fd, UI_BEGIN_FF_UPLOAD, upload);
}
int _uinput_end_upload(int fd, struct uinput_ff_upload *upload)
{
return ioctl(fd, UI_END_FF_UPLOAD, upload);
}
int _uinput_begin_erase(int fd, struct uinput_ff_erase *upload)
{
return ioctl(fd, UI_BEGIN_FF_ERASE, upload);
}
int _uinput_end_erase(int fd, struct uinput_ff_erase *upload)
{
return ioctl(fd, UI_END_FF_ERASE, upload);
}
static PyMethodDef MethodTable[] = {
{ "open", uinput_open, METH_VARARGS,
"Open uinput device node."},
{ "setup", uinput_setup, METH_VARARGS,
"Set an uinput device up."},
{ "create", uinput_create, METH_VARARGS,
"Create an uinput device."},
{ "close", uinput_close, METH_VARARGS,
"Destroy uinput device."},
{ "write", uinput_write, METH_VARARGS,
"Write event to uinput device."},
{ "enable", uinput_enable_event, METH_VARARGS,
"Enable a type of event."},
{ "set_phys", uinput_set_phys, METH_VARARGS,
"Set physical path"},
{ "get_sysname", uinput_get_sysname, METH_VARARGS,
"Obtain the sysname of the uinput device."},
{ "set_prop", uinput_set_prop, METH_VARARGS,
"Set device input property"},
{ NULL, NULL, 0, NULL}
};
static struct PyModuleDef moduledef = {
PyModuleDef_HEAD_INIT,
"_uinput",
"Python bindings for parts of linux/uinput.c",
-1, /* m_size */
MethodTable, /* m_methods */
NULL, /* m_reload */
NULL, /* m_traverse */
NULL, /* m_clear */
NULL, /* m_free */
};
static PyObject *
moduleinit(void)
{
PyObject* m = PyModule_Create(&moduledef);
if (m == NULL) return NULL;
PyModule_AddIntConstant(m, "maxnamelen", UINPUT_MAX_NAME_SIZE);
return m;
}
PyMODINIT_FUNC
PyInit__uinput(void)
{
return moduleinit();
}
================================================
FILE: src/evdev/uinput.py
================================================
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
================================================
FILE: src/evdev/util.py
================================================
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")
================================================
FILE: tests/test_ecodes.py
================================================
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 UI_FF"
def to_tuples(val):
t = lambda x: tuple(x) if isinstance(x, list) else x
return map(t, val)
def test_equality():
keys = []
for i in prefixes.split():
keys.extend(getattr(ecodes, i, {}).keys())
assert set(keys) == set(ecodes.ecodes.values())
def test_access():
assert ecodes.KEY_A == ecodes.ecodes["KEY_A"] == ecodes.KEY_A
assert ecodes.KEY[ecodes.ecodes["KEY_A"]] == "KEY_A"
assert ecodes.REL[0] == "REL_X"
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)
================================================
FILE: tests/test_events.py
================================================
# encoding: utf-8
from evdev import events, ecodes, util
def test_categorize():
e = events.InputEvent(1036996631, 984417, ecodes.EV_KEY, ecodes.KEY_A, 0)
assert isinstance(util.categorize(e), events.KeyEvent)
e = events.InputEvent(1036996631, 984417, ecodes.EV_ABS, 0, 0)
assert isinstance(util.categorize(e), events.AbsEvent)
e = events.InputEvent(1036996631, 984417, ecodes.EV_REL, 0, 0)
assert isinstance(util.categorize(e), events.RelEvent)
e = events.InputEvent(1036996631, 984417, ecodes.EV_MSC, 0, 0)
assert e == util.categorize(e)
def test_keyevent():
e = events.InputEvent(1036996631, 984417, ecodes.EV_KEY, ecodes.KEY_A, 2)
k = events.KeyEvent(e)
assert k.keystate == events.KeyEvent.key_hold
assert k.event == e
assert k.scancode == ecodes.KEY_A
assert k.keycode == "KEY_A" # :todo:
================================================
FILE: tests/test_uinput.py
================================================
# encoding: utf-8
import os
import stat
from select import select
from unittest.mock import patch
import pytest
from pytest import raises, fixture
from evdev import uinput, ecodes, device, UInputError
# -----------------------------------------------------------------------------
uinput_options = {
"name": "test-py-evdev-uinput",
"bustype": ecodes.BUS_USB,
"vendor": 0x1100,
"product": 0x2200,
"version": 0x3300,
}
@fixture
def c():
return uinput_options.copy()
def device_exists(bustype, vendor, product, version):
match = "I: Bus=%04hx Vendor=%04hx Product=%04hx Version=%04hx"
match = match % (bustype, vendor, product, version)
for line in open("/proc/bus/input/devices"):
if line.strip() == match:
return True
return False
# -----------------------------------------------------------------------------
def test_open(c):
ui = uinput.UInput(**c)
args = (c["bustype"], c["vendor"], c["product"], c["version"])
assert device_exists(*args)
ui.close()
assert not device_exists(*args)
def test_open_context(c):
args = (c["bustype"], c["vendor"], c["product"], c["version"])
with uinput.UInput(**c):
assert device_exists(*args)
assert not device_exists(*args)
def test_maxnamelen(c):
with raises(uinput.UInputError):
c["name"] = "a" * 150
uinput.UInput(**c)
def test_enable_events(c):
e = ecodes
c["events"] = {e.EV_KEY: [e.KEY_A, e.KEY_B, e.KEY_C]}
with uinput.UInput(**c) as ui:
cap = ui.capabilities()
assert e.EV_KEY in cap
assert sorted(cap[e.EV_KEY]) == sorted(c["events"][e.EV_KEY])
def test_abs_values(c):
e = ecodes
c = {
e.EV_KEY: [e.KEY_A, e.KEY_B],
e.EV_ABS: [(e.ABS_X, (0, 0, 255, 0, 0)), (e.ABS_Y, device.AbsInfo(0, 0, 255, 5, 10, 0))],
}
with uinput.UInput(events=c) as ui:
c = ui.capabilities()
abs = device.AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=0)
assert c[e.EV_ABS][0] == (0, abs)
abs = device.AbsInfo(value=0, min=0, max=255, fuzz=5, flat=10, resolution=0)
assert c[e.EV_ABS][1] == (1, abs)
c = ui.capabilities(verbose=True)
abs = device.AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=0)
assert c[("EV_ABS", 3)][0] == (("ABS_X", 0), abs)
c = ui.capabilities(verbose=False, absinfo=False)
assert c[e.EV_ABS] == list((0, 1))
def test_write(c):
with uinput.UInput(**c) as ui:
d = ui.device
wrote = False
while True:
r, w, x = select([d], [d], [])
if w and not wrote:
ui.write(ecodes.EV_KEY, ecodes.KEY_P, 1) # KEY_P down
ui.write(ecodes.EV_KEY, ecodes.KEY_P, 1) # KEY_P down
ui.write(ecodes.EV_KEY, ecodes.KEY_P, 0) # KEY_P up
ui.write(ecodes.EV_KEY, ecodes.KEY_A, 1) # KEY_A down
ui.write(ecodes.EV_KEY, ecodes.KEY_A, 2) # KEY_A hold
ui.write(ecodes.EV_KEY, ecodes.KEY_A, 0) # KEY_P up
ui.syn()
wrote = True
if r:
evs = list(d.read())
assert evs[0].code == ecodes.KEY_P and evs[0].value == 1
assert evs[1].code == ecodes.KEY_P and evs[1].value == 0
assert evs[2].code == ecodes.KEY_A and evs[2].value == 1
assert evs[3].code == ecodes.KEY_A and evs[3].value == 2
assert evs[4].code == ecodes.KEY_A and evs[4].value == 0
break
@patch.object(stat, 'S_ISCHR', return_value=False)
def test_not_a_character_device(ischr_mock, c):
with pytest.raises(UInputError, match='not a character device file'):
uinput.UInput(**c)
@patch.object(stat, 'S_ISCHR', return_value=True)
@patch.object(os, 'stat', side_effect=OSError())
def test_not_a_character_device_2(stat_mock, ischr_mock, c):
with pytest.raises(UInputError, match='not a character device file'):
uinput.UInput(**c)
@patch.object(stat, 'S_ISCHR', return_value=True)
@patch.object(os, 'stat', return_value=[])
def test_not_a_character_device_3(stat_mock, ischr_mock, c):
with pytest.raises(UInputError, match='not a character device file'):
uinput.UInput(**c)
================================================
FILE: tests/test_util.py
================================================
from evdev import util
def test_match_ecodes_a():
res = util.find_ecodes_by_regex("KEY_ZOOM.*")
assert res == {1: [372, 418, 419, 420]}
assert dict(util.resolve_ecodes_dict(res)) == {
("EV_KEY", 1): [
(("KEY_FULL_SCREEN", "KEY_ZOOM"), 372),
("KEY_ZOOMIN", 418),
("KEY_ZOOMOUT", 419),
("KEY_ZOOMRESET", 420),
]
}
res = util.find_ecodes_by_regex(r"(ABS|KEY)_BR(AKE|EAK)")
assert res == {1: [411], 3: [10]}
assert dict(util.resolve_ecodes_dict(res)) == {
("EV_KEY", 1): [("KEY_BREAK", 411)],
("EV_ABS", 3): [("ABS_BRAKE", 10)],
}
gitextract_cmbpmvbx/
├── .github/
│ └── workflows/
│ ├── install.yaml
│ ├── lint.yml
│ └── test.yml
├── .gitignore
├── .readthedocs.yaml
├── LICENSE
├── MANIFEST.in
├── README.md
├── docs/
│ ├── Makefile
│ ├── _static/
│ │ └── .keep
│ ├── _templates/
│ │ └── .keep
│ ├── apidoc.rst
│ ├── changelog.rst
│ ├── conf.py
│ ├── index.rst
│ ├── install.rst
│ ├── scope.rst
│ ├── tutorial.rst
│ └── usage.rst
├── examples/
│ └── udev-example.py
├── pyproject.toml
├── requirements-dev.txt
├── scripts/
│ ├── build-binary.sh
│ └── cibw-before.sh
├── setup.py
├── src/
│ └── evdev/
│ ├── __init__.py
│ ├── device.py
│ ├── ecodes.py
│ ├── ecodes_runtime.py
│ ├── eventio.py
│ ├── eventio_async.py
│ ├── events.py
│ ├── evtest.py
│ ├── ff.py
│ ├── genecodes_c.py
│ ├── genecodes_py.py
│ ├── input.c
│ ├── py.typed
│ ├── uinput.c
│ ├── uinput.py
│ └── util.py
└── tests/
├── test_ecodes.py
├── test_events.py
├── test_uinput.py
└── test_util.py
SYMBOL INDEX (187 symbols across 17 files)
FILE: examples/udev-example.py
function helper (line 46) | def helper():
FILE: setup.py
function create_ecodes (line 17) | def create_ecodes(headers=None, reproducible=False):
class build_ecodes (line 75) | class build_ecodes(Command):
method initialize_options (line 83) | def initialize_options(self):
method finalize_options (line 87) | def finalize_options(self):
method run (line 93) | def run(self):
class build_ext (line 97) | class build_ext(_build_ext.build_ext):
method has_ecodes (line 98) | def has_ecodes(self):
method generate_ecodes_py (line 104) | def generate_ecodes_py(self):
method run (line 115) | def run(self):
FILE: src/evdev/device.py
class AbsInfo (line 15) | class AbsInfo(NamedTuple):
method __str__ (line 61) | def __str__(self):
class KbdInfo (line 65) | class KbdInfo(NamedTuple):
method __str__ (line 81) | def __str__(self):
class DeviceInfo (line 85) | class DeviceInfo(NamedTuple):
method __str__ (line 100) | def __str__(self) -> str:
class InputDevice (line 105) | class InputDevice(EventIO, Generic[_AnyStr]):
method __init__ (line 112) | def __init__(self, dev: Union[_AnyStr, "os.PathLike[_AnyStr]"]):
method __del__ (line 156) | def __del__(self) -> None:
method _capabilities (line 163) | def _capabilities(self, absinfo: bool = True):
method capabilities (line 182) | def capabilities(self, verbose: Literal[False] = ..., absinfo: bool = ...
method capabilities (line 185) | def capabilities(self, verbose: Literal[True], absinfo: bool = ...) ->...
method capabilities (line 187) | def capabilities(self, verbose: bool = False, absinfo: bool = True) ->...
method input_props (line 232) | def input_props(self, verbose: bool = False):
method leds (line 253) | def leds(self, verbose: bool = False):
method set_led (line 274) | def set_led(self, led_num: int, value: int) -> None:
method __eq__ (line 284) | def __eq__(self, other):
method __str__ (line 290) | def __str__(self) -> str:
method __repr__ (line 294) | def __repr__(self) -> str:
method __fspath__ (line 298) | def __fspath__(self):
method close (line 301) | def close(self) -> None:
method grab (line 309) | def grab(self) -> None:
method ungrab (line 322) | def ungrab(self) -> None:
method grab_context (line 335) | def grab_context(self) -> Iterator[None]:
method upload_effect (line 344) | def upload_effect(self, effect: "ff.Effect"):
method erase_effect (line 353) | def erase_effect(self, ff_id) -> None:
method repeat (line 362) | def repeat(self):
method repeat (line 371) | def repeat(self, value: Tuple[int, int]):
method active_keys (line 374) | def active_keys(self, verbose: bool = False):
method absinfo (line 397) | def absinfo(self, axis_num: int):
method set_absinfo (line 413) | def set_absinfo(self, axis_num: int, value=None, min=None, max=None, f...
FILE: src/evdev/eventio.py
class EvdevError (line 12) | class EvdevError(Exception):
class EventIO (line 16) | class EventIO:
method fileno (line 31) | def fileno(self):
method read_loop (line 39) | def read_loop(self) -> Iterator[InputEvent]:
method read_one (line 49) | def read_one(self) -> Union[InputEvent, None]:
method read (line 63) | def read(self) -> Iterator[InputEvent]:
method need_write (line 77) | def need_write(func):
method write_event (line 94) | def write_event(self, event):
method write (line 118) | def write(self, etype: int, code: int, value: int):
method syn (line 142) | def syn(self):
method close (line 151) | def close(self):
FILE: src/evdev/eventio_async.py
class ReadIterator (line 17) | class ReadIterator:
method __init__ (line 18) | def __init__(self, device):
method __iter__ (line 23) | def __iter__(self) -> Self:
method __next__ (line 26) | def __next__(self) -> InputEvent:
method __aiter__ (line 35) | def __aiter__(self) -> Self:
method __anext__ (line 38) | def __anext__(self) -> "asyncio.Future[InputEvent]":
class EventIO (line 56) | class EventIO(eventio.EventIO):
method _do_when_readable (line 57) | def _do_when_readable(self, callback):
method _set_result (line 66) | def _set_result(self, future, cb):
method async_read_one (line 72) | def async_read_one(self):
method async_read (line 81) | def async_read(self):
method async_read_loop (line 91) | def async_read_loop(self) -> ReadIterator:
method close (line 99) | def close(self):
FILE: src/evdev/events.py
class InputEvent (line 45) | class InputEvent:
method __init__ (line 50) | def __init__(self, sec, usec, type, code, value):
method timestamp (line 66) | def timestamp(self) -> float:
method __str__ (line 70) | def __str__(self):
method __repr__ (line 74) | def __repr__(self):
class KeyEvent (line 79) | class KeyEvent:
method __init__ (line 88) | def __init__(self, event: InputEvent, allow_unknown: bool = False):
method __str__ (line 115) | def __str__(self):
method __repr__ (line 124) | def __repr__(self):
class RelEvent (line 128) | class RelEvent:
method __init__ (line 133) | def __init__(self, event: InputEvent):
method __str__ (line 137) | def __str__(self):
method __repr__ (line 141) | def __repr__(self):
class AbsEvent (line 145) | class AbsEvent:
method __init__ (line 150) | def __init__(self, event: InputEvent):
method __str__ (line 154) | def __str__(self):
method __repr__ (line 158) | def __repr__(self):
class SynEvent (line 162) | class SynEvent:
method __init__ (line 170) | def __init__(self, event: InputEvent):
method __str__ (line 174) | def __str__(self):
method __repr__ (line 178) | def __repr__(self):
FILE: src/evdev/evtest.py
function parseopt (line 29) | def parseopt():
function main (line 37) | def main():
function select_devices (line 72) | def select_devices(device_dir="/dev/input"):
function print_capabilities (line 112) | def print_capabilities(device):
function print_event (line 148) | def print_event(e):
function toggle_tty_echo (line 167) | def toggle_tty_echo(fh, enable=True):
FILE: src/evdev/ff.py
class Replay (line 12) | class Replay(ctypes.Structure):
class Trigger (line 25) | class Trigger(ctypes.Structure):
class Envelope (line 38) | class Envelope(ctypes.Structure):
class Constant (line 60) | class Constant(ctypes.Structure):
class Ramp (line 73) | class Ramp(ctypes.Structure):
class Condition (line 88) | class Condition(ctypes.Structure):
class Periodic (line 109) | class Periodic(ctypes.Structure):
class Rumble (line 134) | class Rumble(ctypes.Structure):
class EffectType (line 150) | class EffectType(ctypes.Union):
class Effect (line 160) | class Effect(ctypes.Structure):
class UInputUpload (line 171) | class UInputUpload(ctypes.Structure):
class UInputErase (line 180) | class UInputErase(ctypes.Structure):
FILE: src/evdev/genecodes_c.py
function parse_headers (line 119) | def parse_headers(headers=headers):
FILE: src/evdev/input.c
function test_bit (line 40) | int test_bit(const char* bitmask, int bit) {
function PyObject (line 46) | static PyObject *
function PyObject (line 78) | static PyObject *
function PyObject (line 113) | static PyObject *
function PyObject (line 206) | static PyObject *
function PyObject (line 240) | static PyObject *
function PyObject (line 268) | static PyObject *
function PyObject (line 297) | static PyObject *
function PyObject (line 313) | static PyObject *
function PyObject (line 330) | static PyObject *
function PyObject (line 345) | static PyObject *
function PyObject (line 363) | static PyObject *
function PyObject (line 418) | static PyObject *
function print_ff_effect (line 432) | void print_ff_effect(struct ff_effect* effect) {
function PyObject (line 463) | static PyObject *
function PyObject (line 487) | static PyObject *
function PyObject (line 506) | static PyObject *
type PyModuleDef (line 556) | struct PyModuleDef
function PyObject (line 568) | static PyObject *
function PyMODINIT_FUNC (line 576) | PyMODINIT_FUNC
FILE: src/evdev/uinput.c
function _uinput_close (line 29) | int _uinput_close(int fd)
function PyObject (line 42) | static PyObject *
function PyObject (line 60) | static PyObject *
function PyObject (line 80) | static PyObject *
function PyObject (line 100) | static PyObject *
function PyObject (line 127) | static PyObject *
function PyObject (line 186) | static PyObject *
function PyObject (line 235) | static PyObject *
function PyObject (line 255) | static PyObject *
function PyObject (line 272) | static PyObject *
function PyObject (line 301) | static PyObject *
function _uinput_begin_upload (line 339) | int _uinput_begin_upload(int fd, struct uinput_ff_upload *upload)
function _uinput_end_upload (line 344) | int _uinput_end_upload(int fd, struct uinput_ff_upload *upload)
function _uinput_begin_erase (line 349) | int _uinput_begin_erase(int fd, struct uinput_ff_erase *upload)
function _uinput_end_erase (line 354) | int _uinput_end_erase(int fd, struct uinput_ff_erase *upload)
type PyModuleDef (line 391) | struct PyModuleDef
function PyObject (line 403) | static PyObject *
function PyMODINIT_FUNC (line 413) | PyMODINIT_FUNC
FILE: src/evdev/uinput.py
class UInputError (line 20) | class UInputError(Exception):
class UInput (line 24) | class UInput(EventIO):
method from_device (line 43) | def from_device(
method __init__ (line 87) | def __init__(
method _prepare_events (line 185) | def _prepare_events(self, events):
method __enter__ (line 203) | def __enter__(self):
method __exit__ (line 206) | def __exit__(self, type, value, tb):
method __repr__ (line 210) | def __repr__(self):
method __str__ (line 215) | def __str__(self):
method close (line 225) | def close(self):
method capabilities (line 235) | def capabilities(self, verbose: bool = False, absinfo: bool = True):
method begin_upload (line 242) | def begin_upload(self, effect_id):
method end_upload (line 252) | def end_upload(self, upload):
method begin_erase (line 257) | def begin_erase(self, effect_id):
method end_erase (line 266) | def end_erase(self, erase):
method _verify (line 271) | def _verify(self):
method _find_device (line 291) | def _find_device(self, fd: int) -> InputDevice:
method _find_device_linux (line 309) | def _find_device_linux(self, sysname: str) -> InputDevice:
method _find_device_fallback (line 345) | def _find_device_fallback(self) -> Union[InputDevice, None]:
FILE: src/evdev/util.py
function list_devices (line 12) | def list_devices(input_device_dir: Union[str, bytes, os.PathLike] = "/de...
function is_device (line 19) | def is_device(fn: Union[str, bytes, os.PathLike]) -> bool:
function categorize (line 35) | def categorize(event: InputEvent) -> Union[InputEvent, KeyEvent, RelEven...
function resolve_ecodes_dict (line 50) | def resolve_ecodes_dict(typecodemap, unknown="?"):
function resolve_ecodes (line 85) | def resolve_ecodes(ecode_dict, ecode_list, unknown="?"):
function find_ecodes_by_regex (line 114) | def find_ecodes_by_regex(regex):
FILE: tests/test_ecodes.py
function to_tuples (line 8) | def to_tuples(val):
function test_equality (line 13) | def test_equality():
function test_access (line 21) | def test_access():
function test_overlap (line 27) | def test_overlap():
function test_generated (line 33) | def test_generated():
FILE: tests/test_events.py
function test_categorize (line 6) | def test_categorize():
function test_keyevent (line 20) | def test_keyevent():
FILE: tests/test_uinput.py
function c (line 23) | def c():
function device_exists (line 27) | def device_exists(bustype, vendor, product, version):
function test_open (line 39) | def test_open(c):
function test_open_context (line 47) | def test_open_context(c):
function test_maxnamelen (line 54) | def test_maxnamelen(c):
function test_enable_events (line 60) | def test_enable_events(c):
function test_abs_values (line 70) | def test_abs_values(c):
function test_write (line 93) | def test_write(c):
function test_not_a_character_device (line 123) | def test_not_a_character_device(ischr_mock, c):
function test_not_a_character_device_2 (line 129) | def test_not_a_character_device_2(stat_mock, ischr_mock, c):
function test_not_a_character_device_3 (line 135) | def test_not_a_character_device_3(stat_mock, ischr_mock, c):
FILE: tests/test_util.py
function test_match_ecodes_a (line 4) | def test_match_ecodes_a():
Condensed preview — 45 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (176K chars).
[
{
"path": ".github/workflows/install.yaml",
"chars": 702,
"preview": "name: Test install\n\non:\n - push\n - pull_request\n\njobs:\n build:\n runs-on: ${{ matrix.os }}\n strategy:\n fail"
},
{
"path": ".github/workflows/lint.yml",
"chars": 604,
"preview": "name: Lint\n\non:\n - push\n - pull_request\n\njobs:\n pylint:\n runs-on: ${{ matrix.os }}\n strategy:\n fail-fast: "
},
{
"path": ".github/workflows/test.yml",
"chars": 635,
"preview": "name: Test\n\non:\n - push\n - pull_request\n\njobs:\n test:\n runs-on: ${{ matrix.os }}\n strategy:\n fail-fast: fa"
},
{
"path": ".gitignore",
"chars": 329,
"preview": "# --- Python ---\n*.py[co]\n*.egg\n*.egg-info/\ndevelop-eggs/\ndist/\nbuild/\nwheelhouse/\ndropin.cache\npip-log.txt\n.installed.c"
},
{
"path": ".readthedocs.yaml",
"chars": 239,
"preview": "# https://docs.readthedocs.io/en/stable/config-file/v2.html\nversion: 2\n\nbuild:\n os: ubuntu-22.04\n tools:\n python: \""
},
{
"path": "LICENSE",
"chars": 1507,
"preview": "Copyright (c) 2012-2025 Georgi Valkov. All rights reserved.\n\nRedistribution and use in source and binary forms, with or "
},
{
"path": "MANIFEST.in",
"chars": 232,
"preview": "# The _ecodes extension module source file needs to be generated against the\n# evdev headers of the running kernel. Refe"
},
{
"path": "README.md",
"chars": 1171,
"preview": "# evdev\n\n<p>\n <a href=\"https://pypi.python.org/pypi/evdev\"><img alt=\"pypi version\" src=\"https://img.shields.io/pypi/v"
},
{
"path": "docs/Makefile",
"chars": 6030,
"preview": "# Makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS =\nSPHINXBUILD "
},
{
"path": "docs/_static/.keep",
"chars": 0,
"preview": ""
},
{
"path": "docs/_templates/.keep",
"chars": 0,
"preview": ""
},
{
"path": "docs/apidoc.rst",
"chars": 1890,
"preview": "API Reference\n-------------\n\n``events``\n============\n\n.. automodule:: evdev.events\n :members: InputEvent, KeyEvent, Ab"
},
{
"path": "docs/changelog.rst",
"chars": 16531,
"preview": "Changelog\n---------\n\n1.9.3 (Feb 05, 2025)\n====================\n\n- Fix several memory leaks in ``input.c``.\n\n- Raise the "
},
{
"path": "docs/conf.py",
"chars": 8514,
"preview": "import os\nimport sys\nimport sphinx_rtd_theme\n\n# Check if readthedocs is building us\non_rtd = os.environ.get(\"READTHEDOCS"
},
{
"path": "docs/index.rst",
"chars": 1114,
"preview": "Introduction\n------------\n\nThis package provides bindings to the generic input event interface in\nLinux. The *evdev* int"
},
{
"path": "docs/install.rst",
"chars": 3187,
"preview": "From an OS package\n==================\n\nPython-evdev has been packaged for the following distributions:\n\n.. raw:: html\n\n "
},
{
"path": "docs/scope.rst",
"chars": 1240,
"preview": "Scope and status\n----------------\n\nPython-evdev exposes most of the more common interfaces defined in the evdev\nsubsyste"
},
{
"path": "docs/tutorial.rst",
"chars": 14571,
"preview": "Tutorial\n--------\n\n\nListing accessible event devices\n================================\n\n::\n\n >>> import evdev\n\n >>>"
},
{
"path": "docs/usage.rst",
"chars": 2027,
"preview": "Quick Start\n-----------\n\n\nListing accessible event devices\n================================\n\n::\n\n >>> import evdev\n\n "
},
{
"path": "examples/udev-example.py",
"chars": 1743,
"preview": "#!/usr/bin/env python3\n\n\"\"\"\nThis is an example of using pyudev[1] alongside evdev.\n[1]: https://pyudev.readthedocs.org/\n"
},
{
"path": "pyproject.toml",
"chars": 1298,
"preview": "[build-system]\nrequires = [\"setuptools>=77.0\"]\nbuild-backend = \"setuptools.build_meta\"\n\n[project]\nname = \"evdev\"\nversion"
},
{
"path": "requirements-dev.txt",
"chars": 125,
"preview": "pytest\nSphinx\nsphinx-copybutton ~= 0.5.2\nsphinx-rtd-theme\nruff\nbump-my-version ~= 0.17.4\nbuild\ntwine\ncibuildwheel\nsetupt"
},
{
"path": "scripts/build-binary.sh",
"chars": 388,
"preview": "#!/usr/bin/env bash\n\nset -o allexport\nset -o nounset\n\nCIBW_MANYLINUX_X86_64_IMAGE=\"manylinux_2_28\"\nCIBW_MANYLINUX_I686_I"
},
{
"path": "scripts/cibw-before.sh",
"chars": 133,
"preview": "#!/usr/bin/env bash\n\n\nif [ -n \"$PACKAGE_NAME\" ]; then\n sed -i -re 's,^(name = \")evdev(\"),\\1'${PACKAGE_NAME}'\\2,' pypr"
},
{
"path": "setup.py",
"chars": 4731,
"preview": "import os\nimport sys\nimport shutil\nimport textwrap\nimport platform\nfrom pathlib import Path\nfrom subprocess import run\n\n"
},
{
"path": "src/evdev/__init__.py",
"chars": 1011,
"preview": "# --------------------------------------------------------------------------\n# Gather everything into a single, convenie"
},
{
"path": "src/evdev/device.py",
"chars": 12959,
"preview": "import contextlib\nimport os\nfrom typing import Dict, Generic, Iterator, List, Literal, NamedTuple, Tuple, TypeVar, Union"
},
{
"path": "src/evdev/ecodes.py",
"chars": 235,
"preview": "# When installed, this module is replaced by an ecodes.py generated at\n# build time by genecodes_py.py (see build_ext in"
},
{
"path": "src/evdev/ecodes_runtime.py",
"chars": 2838,
"preview": "# pylint: disable=undefined-variable\n\"\"\"\nThis modules exposes the integer constants defined in ``linux/input.h`` and\n``l"
},
{
"path": "src/evdev/eventio.py",
"chars": 4422,
"preview": "import fcntl\nimport functools\nimport os\nimport select\nfrom typing import Iterator, Union\n\nfrom . import _input, _uinput,"
},
{
"path": "src/evdev/eventio_async.py",
"chars": 3078,
"preview": "import asyncio\nimport select\nimport sys\n\nfrom . import eventio\nfrom .events import InputEvent\n\n# needed for compatibilit"
},
{
"path": "src/evdev/events.py",
"chars": 5905,
"preview": "\"\"\"\nThis module provides the :class:`InputEvent` class, which closely\nresembles the ``input_event`` struct defined in ``"
},
{
"path": "src/evdev/evtest.py",
"chars": 5543,
"preview": "\"\"\"\nUsage: evtest [options] [<device>, ...]\n\nInput device enumerator and event monitor.\n\nRunning evtest without any argu"
},
{
"path": "src/evdev/ff.py",
"chars": 4961,
"preview": "import ctypes\n\nfrom . import ecodes\n\n_u8 = ctypes.c_uint8\n_u16 = ctypes.c_uint16\n_u32 = ctypes.c_uint32\n_s16 = ctypes.c_"
},
{
"path": "src/evdev/genecodes_c.py",
"chars": 3618,
"preview": "\"\"\"\nGenerate a Python extension module with the constants defined in linux/input.h.\n\"\"\"\n\nimport getopt\nimport os\nimport "
},
{
"path": "src/evdev/genecodes_py.py",
"chars": 1996,
"preview": "import sys\nfrom unittest import mock\nfrom pprint import PrettyPrinter\n\nsys.modules[\"evdev.ecodes\"] = mock.Mock()\nfrom ev"
},
{
"path": "src/evdev/input.c",
"chars": 16346,
"preview": "\n/*\n * Python bindings to certain linux input subsystem functions.\n *\n * While everything here can be implemented in pur"
},
{
"path": "src/evdev/py.typed",
"chars": 0,
"preview": ""
},
{
"path": "src/evdev/uinput.c",
"chars": 10188,
"preview": "#include <Python.h>\n\n#include <stdio.h>\n#include <string.h>\n#include <errno.h>\n#include <sys/types.h>\n#include <sys/stat"
},
{
"path": "src/evdev/uinput.py",
"chars": 13363,
"preview": "import ctypes\nimport os\nimport platform\nimport re\nimport stat\nimport time\nfrom collections import defaultdict\nfrom typin"
},
{
"path": "src/evdev/util.py",
"chars": 4409,
"preview": "import collections\nimport glob\nimport os\nimport re\nimport stat\nfrom typing import Union, List\n\nfrom . import ecodes\nfrom"
},
{
"path": "tests/test_ecodes.py",
"chars": 1021,
"preview": "from evdev import ecodes\nfrom evdev import ecodes_runtime\n\n\nprefixes = \"KEY ABS REL SW MSC LED BTN REP SND ID EV BUS SYN"
},
{
"path": "tests/test_events.py",
"chars": 860,
"preview": "# encoding: utf-8\n\nfrom evdev import events, ecodes, util\n\n\ndef test_categorize():\n e = events.InputEvent(1036996631,"
},
{
"path": "tests/test_uinput.py",
"chars": 4306,
"preview": "# encoding: utf-8\nimport os\nimport stat\nfrom select import select\nfrom unittest.mock import patch\n\nimport pytest\nfrom py"
},
{
"path": "tests/test_util.py",
"chars": 642,
"preview": "from evdev import util\n\n\ndef test_match_ecodes_a():\n res = util.find_ecodes_by_regex(\"KEY_ZOOM.*\")\n assert res == "
}
]
About this extraction
This page contains the full source code of the gvalkov/python-evdev GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 45 files (162.7 KB), approximately 45.0k tokens, and a symbol index with 187 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.