first commit

myenv/lib/python3.10/site-packages/pynput/__init__.py

@@ -0,0 +1,41 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The main *pynput* module.
+
+This module imports ``keyboard`` and ``mouse``.
+"""
+
+def _logger(cls):
+    """Creates a logger with a name suitable for a specific class.
+
+    This function takes into account that implementations for classes reside in
+    platform dependent modules, and thus removes the final part of the module
+    name.
+
+    :param type cls: The class for which to create a logger.
+
+    :return: a logger
+    """
+    import logging
+    return logging.getLogger('{}.{}'.format(
+        '.'.join(cls.__module__.split('.', 2)[:2]),
+        cls.__name__))
+
+
+from . import keyboard
+from . import mouse

myenv/lib/python3.10/site-packages/pynput/_info.py

@@ -0,0 +1,19 @@
+# coding=utf-8
+# pystray
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = u'Moses Palmér'
+__version__ = (1, 8, 1)

myenv/lib/python3.10/site-packages/pynput/_util/__init__.py

@@ -0,0 +1,489 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+General utility functions and classes.
+"""
+
+# pylint: disable=R0903
+# We implement minimal mixins
+
+# pylint: disable=W0212
+# We implement an internal API
+
+import contextlib
+import functools
+import importlib
+import inspect
+import os
+import sys
+import threading
+import time
+
+import six
+
+from six.moves import queue
+
+
+#: Possible resolutions for import related errors.
+RESOLUTIONS = {
+    'darwin': 'Please make sure that you have Python bindings for the '
+        'system frameworks installed',
+    'uinput': 'Please make sure that you are running as root, and that '
+        'the utility dumpkeys is installed',
+    'xorg': 'Please make sure that you have an X server running, and that '
+        'the DISPLAY environment variable is set correctly'}
+
+
+def backend(package):
+    """Returns the backend module for a package.
+
+    :param str package: The package for which to load a backend.
+    """
+    backend_name = os.environ.get(
+        'PYNPUT_BACKEND_{}'.format(package.rsplit('.')[-1].upper()),
+        os.environ.get('PYNPUT_BACKEND', None))
+    if backend_name:
+        modules = [backend_name]
+    elif sys.platform == 'darwin':
+        modules = ['darwin']
+    elif sys.platform == 'win32':
+        modules = ['win32']
+    else:
+        modules = ['xorg']
+
+    errors = []
+    resolutions = []
+    for module in modules:
+        try:
+            return importlib.import_module('._' + module, package)
+        except ImportError as e:
+            errors.append(e)
+            if module in RESOLUTIONS:
+                resolutions.append(RESOLUTIONS[module])
+
+    raise ImportError('this platform is not supported: {}'.format(
+        '; '.join(str(e) for e in errors)) + ('\n\n'
+            'Try one of the following resolutions:\n\n'
+            + '\n\n'.join(
+                ' * {}'.format(s)
+                for s in resolutions))
+            if resolutions else '')
+
+
+def prefix(base, cls):
+    """Calculates the prefix to use for platform specific options for a
+    specific class.
+
+    The prefix if the name of the module containing the class that is an
+    immediate subclass of ``base`` among the super classes of ``cls``.
+    """
+    for super_cls in filter(
+            lambda cls: issubclass(cls, base),
+            cls.__mro__[1:]):
+        if super_cls is base:
+            return cls.__module__.rsplit('.', 1)[-1][1:] + '_'
+        else:
+            result = prefix(base, super_cls)
+            if result is not None:
+                return result
+
+
+class AbstractListener(threading.Thread):
+    """A class implementing the basic behaviour for event listeners.
+
+    Instances of this class can be used as context managers. This is equivalent
+    to the following code::
+
+        listener.start()
+        listener.wait()
+        try:
+            with_statements()
+        finally:
+            listener.stop()
+
+    Actual implementations of this class must set the attribute ``_log``, which
+    must be an instance of :class:`logging.Logger`.
+
+    :param bool suppress: Whether to suppress events. Setting this to ``True``
+        will prevent the input events from being passed to the rest of the
+        system.
+
+    :param kwargs: A mapping from callback attribute to callback handler. All
+        handlers will be wrapped in a function reading the return value of the
+        callback, and if it ``is False``, raising :class:`StopException`.
+
+        Any callback that is falsy will be ignored.
+    """
+    class StopException(Exception):
+        """If an event listener callback raises this exception, the current
+        listener is stopped.
+        """
+        pass
+
+    #: Exceptions that are handled outside of the emitter and should thus not
+    #: be passed through the queue
+    _HANDLED_EXCEPTIONS = tuple()
+
+    def __init__(self, suppress=False, **kwargs):
+        super(AbstractListener, self).__init__()
+
+        def wrapper(f):
+            def inner(*args):
+                if f(*args) is False:
+                    raise self.StopException()
+            return inner
+
+        self._suppress = suppress
+        self._running = False
+        self._thread = threading.current_thread()
+        self._condition = threading.Condition()
+        self._ready = False
+
+        # Allow multiple calls to stop
+        self._queue = queue.Queue(10)
+
+        self.daemon = True
+
+        for name, callback in kwargs.items():
+            setattr(self, name, wrapper(callback))
+
+    @property
+    def suppress(self):
+        """Whether to suppress events.
+        """
+        return self._suppress
+
+    @property
+    def running(self):
+        """Whether the listener is currently running.
+        """
+        return self._running
+
+    def stop(self):
+        """Stops listening for events.
+
+        When this method returns, no more events will be delivered. Once this
+        method has been called, the listener instance cannot be used any more,
+        since a listener is a :class:`threading.Thread`, and once stopped it
+        cannot be restarted.
+
+        To resume listening for event, a new listener must be created.
+        """
+        if self._running:
+            self._running = False
+            self._queue.put(None)
+            self._stop_platform()
+
+    def __enter__(self):
+        self.start()
+        self.wait()
+        return self
+
+    def __exit__(self, exc_type, value, traceback):
+        self.stop()
+
+    def wait(self):
+        """Waits for this listener to become ready.
+        """
+        self._condition.acquire()
+        while not self._ready:
+            self._condition.wait()
+        self._condition.release()
+
+    def run(self):
+        """The thread runner method.
+        """
+        self._running = True
+        self._thread = threading.current_thread()
+        self._run()
+
+        # Make sure that the queue contains something
+        self._queue.put(None)
+
+    @classmethod
+    def _emitter(cls, f):
+        """A decorator to mark a method as the one emitting the callbacks.
+
+        This decorator will wrap the method and catch exception. If a
+        :class:`StopException` is caught, the listener will be stopped
+        gracefully. If any other exception is caught, it will be propagated to
+        the thread calling :meth:`join` and reraised there.
+        """
+        @functools.wraps(f)
+        def inner(self, *args, **kwargs):
+            # pylint: disable=W0702; we want to catch all exception
+            try:
+                return f(self, *args, **kwargs)
+            except Exception as e:
+                if not isinstance(e, self._HANDLED_EXCEPTIONS):
+                    if not isinstance(e, AbstractListener.StopException):
+                        self._log.exception(
+                            'Unhandled exception in listener callback')
+                    self._queue.put(
+                        None if isinstance(e, cls.StopException)
+                        else sys.exc_info())
+                    self.stop()
+                raise
+            # pylint: enable=W0702
+
+        return inner
+
+    def _mark_ready(self):
+        """Marks this listener as ready to receive events.
+
+        This method must be called from :meth:`_run`. :meth:`wait` will block
+        until this method is called.
+        """
+        self._condition.acquire()
+        self._ready = True
+        self._condition.notify()
+        self._condition.release()
+
+    def _run(self):
+        """The implementation of the :meth:`run` method.
+
+        This is a platform dependent implementation.
+        """
+        raise NotImplementedError()
+
+    def _stop_platform(self):
+        """The implementation of the :meth:`stop` method.
+
+        This is a platform dependent implementation.
+        """
+        raise NotImplementedError()
+
+    def _wrap(self, f, args):
+        """Wraps a callable to make it accept ``args`` number of arguments.
+
+        :param f: The callable to wrap. If this is ``None`` a no-op wrapper is
+            returned.
+
+        :param int args: The number of arguments to accept.
+
+        :raises ValueError: if f requires more than ``args`` arguments
+        """
+        if f is None:
+            return lambda *a: None
+        else:
+            argspec = inspect.getfullargspec(f)
+            actual = len(inspect.signature(f).parameters)
+            defaults = len(argspec.defaults) if argspec.defaults else 0
+            if actual - defaults > args:
+                raise ValueError(f)
+            elif actual >= args or argspec.varargs is not None:
+                return f
+            else:
+                return lambda *a: f(*a[:actual])
+
+    def join(self, timeout=None, *args):
+        start = time.time()
+        super(AbstractListener, self).join(timeout, *args)
+        timeout = max(0.0, timeout - (time.time() - start)) \
+            if timeout is not None \
+            else None
+
+        # Reraise any exceptions; make sure not to block if a timeout was
+        # provided
+        try:
+            exc_type, exc_value, exc_traceback = self._queue.get(
+                timeout=timeout)
+            six.reraise(exc_type, exc_value, exc_traceback)
+        except queue.Empty:
+            pass
+        except TypeError:
+            return
+
+
+class Events(object):
+    """A base class to enable iterating over events.
+    """
+    #: The listener class providing events.
+    _Listener = None
+
+    class Event(object):
+        def __str__(self):
+            return '{}({})'.format(
+                self.__class__.__name__,
+                ', '.join(
+                    '{}={}'.format(k, v)
+                    for (k, v) in vars(self).items()))
+
+        def __eq__(self, other):
+            return self.__class__ == other.__class__ \
+                and dir(self) == dir(other) \
+                and all(
+                    getattr(self, k) == getattr(other, k)
+                    for k in dir(self))
+
+    def __init__(self, *args, **kwargs):
+        super(Events, self).__init__()
+        self._event_queue = queue.Queue()
+        self._sentinel = object()
+        self._listener = self._Listener(*args, **{
+            key: self._event_mapper(value)
+            for (key, value) in kwargs.items()})
+        self.start = self._listener.start
+
+    def __enter__(self):
+        self._listener.__enter__()
+        return self
+
+    def __exit__(self, *args):
+        self._listener.__exit__(*args)
+
+        # Drain the queue to ensure that the put does not block
+        while True:
+            try:
+                self._event_queue.get_nowait()
+            except queue.Empty:
+                break
+
+        self._event_queue.put(self._sentinel)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        event = self.get()
+        if event is not None:
+            return event
+        else:
+            raise StopIteration()
+
+    def get(self, timeout=None):
+        """Attempts to read the next event.
+
+        :param int timeout: An optional timeout. If this is not provided, this
+            method may block infinitely.
+
+        :return: the next event, or ``None`` if the source has been stopped or
+            no events were received
+        """
+        try:
+            event = self._event_queue.get(timeout=timeout)
+            return event if event is not self._sentinel else None
+        except queue.Empty:
+            return None
+
+    def _event_mapper(self, event):
+        """Generates an event callback to transforms the callback arguments to
+        an event and then publishes it.
+
+        :param callback event: A function generating an event object.
+
+        :return: a callback
+        """
+        @functools.wraps(event)
+        def inner(*args):
+            try:
+                self._event_queue.put(event(*args), block=False)
+            except queue.Full:
+                pass
+
+        return inner
+
+
+class NotifierMixin(object):
+    """A mixin for notifiers of fake events.
+
+    This mixin can be used for controllers on platforms where sending fake
+    events does not cause a listener to receive a notification.
+    """
+    def _emit(self, action, *args):
+        """Sends a notification to all registered listeners.
+
+        This method will ensure that listeners that raise
+        :class:`StopException` are stopped.
+
+        :param str action: The name of the notification.
+
+        :param args: The arguments to pass.
+        """
+        stopped = []
+        for listener in self._listeners():
+            try:
+                getattr(listener, action)(*args)
+            except listener.StopException:
+                stopped.append(listener)
+        for listener in stopped:
+            listener.stop()
+
+    @classmethod
+    def _receiver(cls, listener_class):
+        """A decorator to make a class able to receive fake events from a
+        controller.
+
+        This decorator will add the method ``_receive`` to the decorated class.
+
+        This method is a context manager which ensures that all calls to
+        :meth:`_emit` will invoke the named method in the listener instance
+        while the block is active.
+        """
+        @contextlib.contextmanager
+        def receive(self):
+            """Executes a code block with this listener instance registered as
+            a receiver of fake input events.
+            """
+            self._controller_class._add_listener(self)
+            try:
+                yield
+            finally:
+                self._controller_class._remove_listener(self)
+
+        listener_class._receive = receive
+        listener_class._controller_class = cls
+
+        # Make sure this class has the necessary attributes
+        if not hasattr(cls, '_listener_cache'):
+            cls._listener_cache = set()
+            cls._listener_lock = threading.Lock()
+
+        return listener_class
+
+    @classmethod
+    def _listeners(cls):
+        """Iterates over the set of running listeners.
+
+        This method will quit without acquiring the lock if the set is empty,
+        so there is potential for race conditions. This is an optimisation,
+        since :class:`Controller` will need to call this method for every
+        control event.
+        """
+        if not cls._listener_cache:
+            return
+        with cls._listener_lock:
+            for listener in cls._listener_cache:
+                yield listener
+
+    @classmethod
+    def _add_listener(cls, listener):
+        """Adds a listener to the set of running listeners.
+
+        :param listener: The listener for fake events.
+        """
+        with cls._listener_lock:
+            cls._listener_cache.add(listener)
+
+    @classmethod
+    def _remove_listener(cls, listener):
+        """Removes this listener from the set of running listeners.
+
+        :param listener: The listener for fake events.
+        """
+        with cls._listener_lock:
+            cls._listener_cache.remove(listener)

myenv/lib/python3.10/site-packages/pynput/_util/darwin.py

@@ -0,0 +1,302 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+Utility functions and classes for the *Darwin* backend.
+"""
+
+# pylint: disable=C0103
+# pylint: disable=R0903
+# This module contains wrapper classes
+
+import contextlib
+import ctypes
+import ctypes.util
+import six
+
+import objc
+import HIServices
+
+from CoreFoundation import (
+    CFRelease
+)
+
+from Quartz import (
+    CFMachPortCreateRunLoopSource,
+    CFRunLoopAddSource,
+    CFRunLoopGetCurrent,
+    CFRunLoopRunInMode,
+    CFRunLoopStop,
+    CGEventGetIntegerValueField,
+    CGEventTapCreate,
+    CGEventTapEnable,
+    kCFRunLoopDefaultMode,
+    kCFRunLoopRunTimedOut,
+    kCGEventSourceUnixProcessID,
+    kCGEventTapOptionDefault,
+    kCGEventTapOptionListenOnly,
+    kCGHeadInsertEventTap,
+    kCGSessionEventTap)
+
+
+from . import AbstractListener
+
+
+def _wrap_value(value):
+    """Converts a pointer to a *Python objc* value.
+
+    :param value: The pointer to convert.
+
+    :return: a wrapped value
+    """
+    return objc.objc_object(c_void_p=value) if value is not None else None
+
+
+@contextlib.contextmanager
+def _wrapped(value):
+    """A context manager that converts a raw pointer to a *Python objc* value.
+
+    When the block is exited, the value is released.
+
+    :param value: The raw value to wrap.
+    """
+    wrapped_value = _wrap_value(value)
+
+    try:
+        yield value
+    finally:
+        CFRelease(wrapped_value)
+
+
+class CarbonExtra(object):
+    """A class exposing some missing functionality from *Carbon* as class
+    attributes.
+    """
+    _Carbon = ctypes.cdll.LoadLibrary(ctypes.util.find_library('Carbon'))
+
+    _Carbon.TISCopyCurrentKeyboardInputSource.argtypes = []
+    _Carbon.TISCopyCurrentKeyboardInputSource.restype = ctypes.c_void_p
+
+    _Carbon.TISCopyCurrentASCIICapableKeyboardLayoutInputSource.argtypes = []
+    _Carbon.TISCopyCurrentASCIICapableKeyboardLayoutInputSource.restype = \
+        ctypes.c_void_p
+
+    _Carbon.TISGetInputSourceProperty.argtypes = [
+        ctypes.c_void_p, ctypes.c_void_p]
+    _Carbon.TISGetInputSourceProperty.restype = ctypes.c_void_p
+
+    _Carbon.LMGetKbdType.argtypes = []
+    _Carbon.LMGetKbdType.restype = ctypes.c_uint32
+
+    _Carbon.UCKeyTranslate.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_uint16,
+        ctypes.c_uint16,
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+        ctypes.POINTER(ctypes.c_uint32),
+        ctypes.c_uint8,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint16 * 4]
+    _Carbon.UCKeyTranslate.restype = ctypes.c_uint32
+
+    TISCopyCurrentKeyboardInputSource = \
+        _Carbon.TISCopyCurrentKeyboardInputSource
+
+    TISCopyCurrentASCIICapableKeyboardLayoutInputSource = \
+        _Carbon.TISCopyCurrentASCIICapableKeyboardLayoutInputSource
+
+    kTISPropertyUnicodeKeyLayoutData = ctypes.c_void_p.in_dll(
+        _Carbon, 'kTISPropertyUnicodeKeyLayoutData')
+
+    TISGetInputSourceProperty = \
+        _Carbon.TISGetInputSourceProperty
+
+    LMGetKbdType = \
+        _Carbon.LMGetKbdType
+
+    kUCKeyActionDisplay = 3
+    kUCKeyTranslateNoDeadKeysBit = 0
+
+    UCKeyTranslate = \
+        _Carbon.UCKeyTranslate
+
+
+@contextlib.contextmanager
+def keycode_context():
+    """Returns an opaque value representing a context for translating keycodes
+    to strings.
+    """
+    keyboard_type, layout_data = None, None
+    for source in [
+            CarbonExtra.TISCopyCurrentKeyboardInputSource,
+            CarbonExtra.TISCopyCurrentASCIICapableKeyboardLayoutInputSource]:
+        with _wrapped(source()) as keyboard:
+            keyboard_type = CarbonExtra.LMGetKbdType()
+            layout = _wrap_value(CarbonExtra.TISGetInputSourceProperty(
+                keyboard,
+                CarbonExtra.kTISPropertyUnicodeKeyLayoutData))
+            layout_data = layout.bytes().tobytes() if layout else None
+            if keyboard is not None and layout_data is not None:
+                break
+    yield (keyboard_type, layout_data)
+
+
+def keycode_to_string(context, keycode, modifier_state=0):
+    """Converts a keycode to a string.
+    """
+    LENGTH = 4
+
+    keyboard_type, layout_data = context
+
+    dead_key_state = ctypes.c_uint32()
+    length = ctypes.c_uint8()
+    unicode_string = (ctypes.c_uint16 * LENGTH)()
+    CarbonExtra.UCKeyTranslate(
+        layout_data,
+        keycode,
+        CarbonExtra.kUCKeyActionDisplay,
+        modifier_state,
+        keyboard_type,
+        CarbonExtra.kUCKeyTranslateNoDeadKeysBit,
+        ctypes.byref(dead_key_state),
+        LENGTH,
+        ctypes.byref(length),
+        unicode_string)
+    return u''.join(
+        six.unichr(unicode_string[i])
+        for i in range(length.value))
+
+
+def get_unicode_to_keycode_map():
+    """Returns a mapping from unicode strings to virtual key codes.
+
+    :return: a dict mapping key codes to strings
+    """
+    with keycode_context() as context:
+        return {
+            keycode_to_string(context, keycode): keycode
+            for keycode in range(128)}
+
+
+class ListenerMixin(object):
+    """A mixin for *Quartz* event listeners.
+
+    Subclasses should set a value for :attr:`_EVENTS` and implement
+    :meth:`_handle_message`.
+    """
+    #: The events that we listen to
+    _EVENTS = tuple()
+
+    #: Whether this process is trusted to monitor input events.
+    IS_TRUSTED = False
+
+    def _run(self):
+        self.IS_TRUSTED = HIServices.AXIsProcessTrusted()
+        if not self.IS_TRUSTED:
+            self._log.warning(
+                'This process is not trusted! Input event monitoring will not '
+                'be possible until it is added to accessibility clients.')
+
+        self._loop = None
+        try:
+            tap = self._create_event_tap()
+            if tap is None:
+                self._mark_ready()
+                return
+
+            loop_source = CFMachPortCreateRunLoopSource(
+                None, tap, 0)
+            self._loop = CFRunLoopGetCurrent()
+
+            CFRunLoopAddSource(
+                self._loop, loop_source, kCFRunLoopDefaultMode)
+            CGEventTapEnable(tap, True)
+
+            self._mark_ready()
+
+            # pylint: disable=W0702; we want to silence errors
+            try:
+                while self.running:
+                    result = CFRunLoopRunInMode(
+                        kCFRunLoopDefaultMode, 1, False)
+                    try:
+                        if result != kCFRunLoopRunTimedOut:
+                            break
+                    except AttributeError:
+                        # This happens during teardown of the virtual machine
+                        break
+
+            except:
+                # This exception will have been passed to the main thread
+                pass
+            # pylint: enable=W0702
+
+        finally:
+            self._loop = None
+
+    def _stop_platform(self):
+        # The base class sets the running flag to False; this will cause the
+        # loop around run loop invocations to terminate and set this event
+        try:
+            if self._loop is not None:
+                CFRunLoopStop(self._loop)
+        except AttributeError:
+            # The loop may not have been created
+            pass
+
+    def _create_event_tap(self):
+        """Creates the event tap used by the listener.
+
+        :return: an event tap
+        """
+        return CGEventTapCreate(
+            kCGSessionEventTap,
+            kCGHeadInsertEventTap,
+            kCGEventTapOptionListenOnly if (
+                True
+                and not self.suppress
+                and self._intercept is None)
+            else kCGEventTapOptionDefault,
+            self._EVENTS,
+            self._handler,
+            None)
+
+    @AbstractListener._emitter
+    def _handler(self, proxy, event_type, event, refcon):
+        """The callback registered with *macOS* for mouse events.
+
+        This method will call the callbacks registered on initialisation.
+        """
+        # An injected event will have a Unix process ID attached
+        is_injected = (CGEventGetIntegerValueField(
+            event,
+            kCGEventSourceUnixProcessID)) != 0
+
+        self._handle_message(proxy, event_type, event, refcon, is_injected)
+        if self._intercept is not None:
+            return self._intercept(event_type, event)
+        elif self.suppress:
+            return None
+
+    def _handle_message(self, proxy, event_type, event, refcon):
+        """The device specific callback handler.
+
+        This method calls the appropriate callback registered when this
+        listener was created based on the event.
+        """
+        raise NotImplementedError()

myenv/lib/python3.10/site-packages/pynput/_util/darwin_vks.py

@@ -0,0 +1,79 @@
+# coding: utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# pylint: disable=C0111,C0302
+
+SYMBOLS = {
+    0: 'a',
+    1: 's',
+    2: 'd',
+    3: 'f',
+    4: 'h',
+    5: 'g',
+    6: 'z',
+    7: 'x',
+    8: 'c',
+    9: 'v',
+    11: 'b',
+    12: 'q',
+    13: 'w',
+    14: 'e',
+    15: 'r',
+    16: 'y',
+    17: 't',
+    18: '1',
+    19: '2',
+    20: '3',
+    21: '4',
+    22: '6',
+    23: '5',
+    24: '=',
+    25: '9',
+    26: '7',
+    27: '-',
+    28: '8',
+    29: '0',
+    30: ']',
+    31: 'o',
+    32: 'u',
+    33: '[',
+    34: 'i',
+    35: 'p',
+    37: 'l',
+    38: 'j',
+    39: '\'',
+    40: 'k',
+    41: ';',
+    42: '\\',
+    43: ',',
+    44: '/',
+    45: 'n',
+    46: 'm',
+    47: '.',
+    49: ' ',
+    50: '`',
+    82: '0',
+    83: '1',
+    84: '2',
+    85: '3',
+    86: '4',
+    87: '5',
+    88: '6',
+    89: '7',
+    91: '8',
+    92: '9',
+}

myenv/lib/python3.10/site-packages/pynput/_util/uinput.py

@@ -0,0 +1,99 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+Utility functions and classes for the *uinput* backend.
+"""
+
+# pylint: disable=R0903
+# We implement stubs
+
+import evdev
+
+
+# Check that we have permissions to continue
+def _check():
+    # TODO: Implement!
+    pass
+_check()
+del _check
+
+
+class ListenerMixin(object):
+    """A mixin for *uinput* event listeners.
+
+    Subclasses should set a value for :attr:`_EVENTS` and implement
+    :meth:`_handle_message`.
+    """
+    #: The events for which to listen
+    _EVENTS = tuple()
+
+    def __init__(self, *args, **kwargs):
+        super(ListenerMixin, self).__init__(*args, **kwargs)
+        self._dev = self._device(self._options.get(
+            'device_paths',
+            evdev.list_devices()))
+        if self.suppress:
+            self._dev.grab()
+
+    def _run(self):
+        for event in self._dev.read_loop():
+            if event.type in self._EVENTS:
+                self._handle_message(event)
+
+    def _stop_platform(self):
+        self._dev.close()
+
+    def _device(self, paths):
+        """Attempts to load a readable keyboard device.
+
+        :param paths: A list of paths.
+
+        :return: a compatible device
+        """
+        dev, count = None, 0
+        for path in paths:
+            # Open the device
+            try:
+                next_dev = evdev.InputDevice(path)
+            except OSError:
+                continue
+
+            # Does this device provide more handled event codes?
+            capabilities = next_dev.capabilities()
+            next_count = sum(
+                len(codes)
+                for event, codes in capabilities.items()
+                if event in self._EVENTS)
+            if next_count > count:
+                dev = next_dev
+                count = next_count
+            else:
+                next_dev.close()
+
+        if dev is None:
+            raise OSError('no keyboard device available')
+        else:
+            return dev
+
+    def _handle_message(self, event):
+        """Handles a single event.
+
+        This method should call one of the registered event callbacks.
+
+        :param event: The event.
+        """
+        raise NotImplementedError()

myenv/lib/python3.10/site-packages/pynput/_util/win32.py

@@ -0,0 +1,598 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+Utility functions and classes for the *win32* backend.
+"""
+
+# pylint: disable=C0103
+# We want to make it obvious how structs are related
+
+# pylint: disable=R0903
+# This module contains a number of structs
+
+import contextlib
+import ctypes
+import itertools
+import threading
+
+from ctypes import (
+    windll,
+    wintypes)
+
+from . import AbstractListener, win32_vks as VK
+
+
+# LPDWORD is not in ctypes.wintypes on Python 2
+if not hasattr(wintypes, 'LPDWORD'):
+    wintypes.LPDWORD = ctypes.POINTER(wintypes.DWORD)
+
+
+class MOUSEINPUT(ctypes.Structure):
+    """Contains information about a simulated mouse event.
+    """
+    MOVE = 0x0001
+    LEFTDOWN = 0x0002
+    LEFTUP = 0x0004
+    RIGHTDOWN = 0x0008
+    RIGHTUP = 0x0010
+    MIDDLEDOWN = 0x0020
+    MIDDLEUP = 0x0040
+    XDOWN = 0x0080
+    XUP = 0x0100
+    WHEEL = 0x0800
+    HWHEEL = 0x1000
+    ABSOLUTE = 0x8000
+
+    XBUTTON1 = 0x0001
+    XBUTTON2 = 0x0002
+
+    _fields_ = [
+        ('dx', wintypes.LONG),
+        ('dy', wintypes.LONG),
+        ('mouseData', wintypes.DWORD),
+        ('dwFlags', wintypes.DWORD),
+        ('time', wintypes.DWORD),
+        ('dwExtraInfo', ctypes.c_void_p)]
+
+
+class KEYBDINPUT(ctypes.Structure):
+    """Contains information about a simulated keyboard event.
+    """
+    EXTENDEDKEY = 0x0001
+    KEYUP = 0x0002
+    SCANCODE = 0x0008
+    UNICODE = 0x0004
+
+    _fields_ = [
+        ('wVk', wintypes.WORD),
+        ('wScan', wintypes.WORD),
+        ('dwFlags', wintypes.DWORD),
+        ('time', wintypes.DWORD),
+        ('dwExtraInfo', ctypes.c_void_p)]
+
+
+class HARDWAREINPUT(ctypes.Structure):
+    """Contains information about a simulated message generated by an input
+    device other than a keyboard or mouse.
+    """
+    _fields_ = [
+        ('uMsg', wintypes.DWORD),
+        ('wParamL', wintypes.WORD),
+        ('wParamH', wintypes.WORD)]
+
+
+class INPUT_union(ctypes.Union):
+    """Represents the union of input types in :class:`INPUT`.
+    """
+    _fields_ = [
+        ('mi', MOUSEINPUT),
+        ('ki', KEYBDINPUT),
+        ('hi', HARDWAREINPUT)]
+
+
+class INPUT(ctypes.Structure):
+    """Used by :attr:`SendInput` to store information for synthesizing input
+    events such as keystrokes, mouse movement, and mouse clicks.
+    """
+    MOUSE = 0
+    KEYBOARD = 1
+    HARDWARE = 2
+
+    _fields_ = [
+        ('type', wintypes.DWORD),
+        ('value', INPUT_union)]
+
+
+LPINPUT = ctypes.POINTER(INPUT)
+
+VkKeyScan = windll.user32.VkKeyScanW
+VkKeyScan.argtypes = (
+    wintypes.WCHAR,)
+
+MapVirtualKey = windll.user32.MapVirtualKeyW
+MapVirtualKey.argtypes = (
+    wintypes.UINT,
+    wintypes.UINT)
+MapVirtualKey.MAPVK_VK_TO_VSC = 0
+
+SendInput = windll.user32.SendInput
+SendInput.argtypes = (
+    wintypes.UINT,
+    ctypes.c_voidp,  # Really LPINPUT
+    ctypes.c_int)
+
+GetCurrentThreadId = windll.kernel32.GetCurrentThreadId
+GetCurrentThreadId.restype = wintypes.DWORD
+
+
+class MessageLoop(object):
+    """A class representing a message loop.
+    """
+    #: The message that signals this loop to terminate
+    WM_STOP = 0x0401
+
+    _LPMSG = ctypes.POINTER(wintypes.MSG)
+
+    _GetMessage = windll.user32.GetMessageW
+    _GetMessage.argtypes = (
+        ctypes.c_voidp,  # Really _LPMSG
+        wintypes.HWND,
+        wintypes.UINT,
+        wintypes.UINT)
+    _PeekMessage = windll.user32.PeekMessageW
+    _PeekMessage.argtypes = (
+        ctypes.c_voidp,  # Really _LPMSG
+        wintypes.HWND,
+        wintypes.UINT,
+        wintypes.UINT,
+        wintypes.UINT)
+    _PostThreadMessage = windll.user32.PostThreadMessageW
+    _PostThreadMessage.argtypes = (
+        wintypes.DWORD,
+        wintypes.UINT,
+        wintypes.WPARAM,
+        wintypes.LPARAM)
+
+    PM_NOREMOVE = 0
+
+    def __init__(self):
+        self._threadid = None
+        self._event = threading.Event()
+        self.thread = None
+
+    def __iter__(self):
+        """Initialises the message loop and yields all messages until
+        :meth:`stop` is called.
+
+        :raises AssertionError: if :meth:`start` has not been called
+        """
+        assert self._threadid is not None
+
+        try:
+            # Pump messages until WM_STOP
+            while True:
+                msg = wintypes.MSG()
+                lpmsg = ctypes.byref(msg)
+                r = self._GetMessage(lpmsg, None, 0, 0)
+                if r <= 0 or msg.message == self.WM_STOP:
+                    break
+                else:
+                    yield msg
+
+        finally:
+            self._threadid = None
+            self.thread = None
+
+    def start(self):
+        """Starts the message loop.
+
+        This method must be called before iterating over messages, and it must
+        be called from the same thread.
+        """
+        self._threadid = GetCurrentThreadId()
+        self.thread = threading.current_thread()
+
+        # Create the message loop
+        msg = wintypes.MSG()
+        lpmsg = ctypes.byref(msg)
+        self._PeekMessage(lpmsg, None, 0x0400, 0x0400, self.PM_NOREMOVE)
+
+        # Set the event to signal to other threads that the loop is created
+        self._event.set()
+
+    def stop(self):
+        """Stops the message loop.
+        """
+        self._event.wait()
+        if self._threadid:
+            self.post(self.WM_STOP, 0, 0)
+
+    def post(self, msg, wparam, lparam):
+        """Posts a message to this message loop.
+
+        :param ctypes.wintypes.UINT msg: The message.
+
+        :param ctypes.wintypes.WPARAM wparam: The value of ``wParam``.
+
+        :param ctypes.wintypes.LPARAM lparam: The value of ``lParam``.
+        """
+        self._PostThreadMessage(self._threadid, msg, wparam, lparam)
+
+
+class SystemHook(object):
+    """A class to handle Windows hooks.
+    """
+    #: The hook action value for actions we should check
+    HC_ACTION = 0
+
+    _HOOKPROC = ctypes.WINFUNCTYPE(
+        wintypes.LPARAM,
+        ctypes.c_int32, wintypes.WPARAM, wintypes.LPARAM)
+
+    _SetWindowsHookEx = windll.user32.SetWindowsHookExW
+    _SetWindowsHookEx.argtypes = (
+        ctypes.c_int,
+        _HOOKPROC,
+        wintypes.HINSTANCE,
+        wintypes.DWORD)
+    _UnhookWindowsHookEx = windll.user32.UnhookWindowsHookEx
+    _UnhookWindowsHookEx.argtypes = (
+        wintypes.HHOOK,)
+    _CallNextHookEx = windll.user32.CallNextHookEx
+    _CallNextHookEx.argtypes = (
+        wintypes.HHOOK,
+        ctypes.c_int,
+        wintypes.WPARAM,
+        wintypes.LPARAM)
+
+    #: The registered hook procedures
+    _HOOKS = {}
+
+    class SuppressException(Exception):
+        """An exception raised by a hook callback to suppress further
+        propagation of events.
+        """
+        pass
+
+    def __init__(self, hook_id, on_hook=lambda code, msg, lpdata: None):
+        self.hook_id = hook_id
+        self.on_hook = on_hook
+        self._hook = None
+
+    def __enter__(self):
+        key = threading.current_thread().ident
+        assert key not in self._HOOKS
+
+        # Add ourself to lookup table and install the hook
+        self._HOOKS[key] = self
+        self._hook = self._SetWindowsHookEx(
+            self.hook_id,
+            self._handler,
+            None,
+            0)
+
+        return self
+
+    def __exit__(self, exc_type, value, traceback):
+        key = threading.current_thread().ident
+        assert key in self._HOOKS
+
+        if self._hook is not None:
+            # Uninstall the hook and remove ourself from lookup table
+            self._UnhookWindowsHookEx(self._hook)
+            del self._HOOKS[key]
+
+    @staticmethod
+    @_HOOKPROC
+    def _handler(code, msg, lpdata):
+        key = threading.current_thread().ident
+        self = SystemHook._HOOKS.get(key, None)
+        if self:
+            # pylint: disable=W0702; we want to silence errors
+            try:
+                self.on_hook(code, msg, lpdata)
+            except self.SuppressException:
+                # Return non-zero to stop event propagation
+                return 1
+            except:
+                # Ignore any errors
+                pass
+            # pylint: enable=W0702
+            return SystemHook._CallNextHookEx(0, code, msg, lpdata)
+
+
+class ListenerMixin(object):
+    """A mixin for *win32* event listeners.
+
+    Subclasses should set a value for :attr:`_EVENTS` and implement
+    :meth:`_handle_message`.
+
+    Subclasses must also be decorated with a decorator compatible with
+    :meth:`pynput._util.NotifierMixin._receiver` or implement the method
+    ``_receive()``.
+    """
+    #: The Windows hook ID for the events to capture.
+    _EVENTS = None
+
+    #: The window message used to signal that an even should be handled.
+    _WM_PROCESS = 0x410
+
+    #: Additional window messages to propagate to the subclass handler.
+    _WM_NOTIFICATIONS = []
+
+    def suppress_event(self):
+        """Causes the currently filtered event to be suppressed.
+
+        This has a system wide effect and will generally result in no
+        applications receiving the event.
+
+        This method will raise an undefined exception.
+        """
+        raise SystemHook.SuppressException()
+
+    def _run(self):
+        self._message_loop = MessageLoop()
+        with self._receive():
+            self._mark_ready()
+            self._message_loop.start()
+
+            # pylint: disable=W0702; we want to silence errors
+            try:
+                with SystemHook(self._EVENTS, self._handler):
+                    # Just pump messages
+                    for msg in self._message_loop:
+                        if not self.running:
+                            break
+                        if msg.message == self._WM_PROCESS:
+                            self._process(msg.wParam, msg.lParam)
+                        elif msg.message in self._WM_NOTIFICATIONS:
+                            self._on_notification(
+                                msg.message, msg.wParam, msg.lParam)
+            except:
+                # This exception will have been passed to the main thread
+                pass
+            # pylint: enable=W0702
+
+    def _stop_platform(self):
+        try:
+            self._message_loop.stop()
+        except AttributeError:
+            # The loop may not have been created
+            pass
+
+    @AbstractListener._emitter
+    def _handler(self, code, msg, lpdata):
+        """The callback registered with *Windows* for events.
+
+        This method will post the message :attr:`_WM_PROCESS` to the message
+        loop started with this listener using :meth:`MessageLoop.post`. The
+        parameters are retrieved with a call to :meth:`_handle`.
+        """
+        try:
+            converted = self._convert(code, msg, lpdata)
+            if converted is not None:
+                self._message_loop.post(self._WM_PROCESS, *converted)
+        except NotImplementedError:
+            self._handle_message(code, msg, lpdata)
+
+        if self.suppress:
+            self.suppress_event()
+
+    def _convert(self, code, msg, lpdata):
+        """The device specific callback handler.
+
+        This method converts a low-level message and data to a
+        ``WPARAM`` / ``LPARAM`` pair.
+        """
+        raise NotImplementedError()
+
+    def _process(self, wparam, lparam):
+        """The device specific callback handler.
+
+        This method performs the actual dispatching of events.
+        """
+        raise NotImplementedError()
+
+    def _handle_message(self, code, msg, lpdata):
+        """The device specific callback handler.
+
+        This method calls the appropriate callback registered when this
+        listener was created based on the event.
+
+        This method is only called if :meth:`_convert` is not implemented.
+        """
+        raise NotImplementedError()
+
+    def _on_notification(self, code, wparam, lparam):
+        """An additional notification handler.
+
+        This method will be called for every message in
+        :attr:`_WM_NOTIFICATIONS`.
+        """
+        raise NotImplementedError()
+
+
+class KeyTranslator(object):
+    """A class to translate virtual key codes to characters.
+    """
+    _GetAsyncKeyState = ctypes.windll.user32.GetAsyncKeyState
+    _GetAsyncKeyState.argtypes = (
+        ctypes.c_int,)
+    _GetKeyboardLayout = ctypes.windll.user32.GetKeyboardLayout
+    _GetKeyboardLayout.argtypes = (
+        wintypes.DWORD,)
+    _GetKeyboardState = ctypes.windll.user32.GetKeyboardState
+    _GetKeyboardState.argtypes = (
+        ctypes.c_voidp,)
+    _GetKeyState = ctypes.windll.user32.GetAsyncKeyState
+    _GetKeyState.argtypes = (
+        ctypes.c_int,)
+    _MapVirtualKeyEx = ctypes.windll.user32.MapVirtualKeyExW
+    _MapVirtualKeyEx.argtypes = (
+        wintypes.UINT,
+        wintypes.UINT,
+        wintypes.HKL)
+    _ToUnicodeEx = ctypes.windll.user32.ToUnicodeEx
+    _ToUnicodeEx.argtypes = (
+        wintypes.UINT,
+        wintypes.UINT,
+        ctypes.c_voidp,
+        ctypes.c_voidp,
+        ctypes.c_int,
+        wintypes.UINT,
+        wintypes.HKL)
+
+    _MAPVK_VK_TO_VSC = 0
+    _MAPVK_VSC_TO_VK = 1
+    _MAPVK_VK_TO_CHAR = 2
+
+    def __init__(self):
+        self.update_layout()
+
+    def __call__(self, vk, is_press):
+        """Converts a virtual key code to a string.
+
+        :param int vk: The virtual key code.
+
+        :param bool is_press: Whether this is a press.
+
+        :return: parameters suitable for the :class:`pynput.keyboard.KeyCode`
+            constructor
+
+        :raises OSError: if a call to any *win32* function fails
+        """
+        # Get a string representation of the key
+        layout_data = self._layout_data[self._modifier_state()]
+        scan = self._to_scan(vk, self._layout)
+        character, is_dead = layout_data[scan]
+
+        return {
+            'char': character,
+            'is_dead': is_dead,
+            'vk': vk,
+            '_scan': scan}
+
+    def update_layout(self):
+        """Updates the cached layout data.
+        """
+        self._layout, self._layout_data = self._generate_layout()
+
+    def char_from_scan(self, scan):
+        """Translates a scan code to a character, if possible.
+
+        :param int scan: The scan code to translate.
+
+        :return: maybe a character
+        :rtype: str or None
+        """
+        return self._layout_data[(False, False, False)][scan][0]
+
+    def _generate_layout(self):
+        """Generates the keyboard layout.
+
+        This method will call ``ToUnicodeEx``, which modifies kernel buffers,
+        so it must *not* be called from the keyboard hook.
+
+        The return value is the tuple ``(layout_handle, layout_data)``, where
+        ``layout_data`` is a mapping from the tuple ``(shift, ctrl, alt)`` to
+        an array indexed by scan code containing the data
+        ``(character, is_dead)``, and ``layout_handle`` is the handle of the
+        layout.
+
+        :return: a composite layout
+        """
+        layout_data = {}
+
+        state = (ctypes.c_ubyte * 255)()
+        with self._thread_input() as active_thread:
+            layout = self._GetKeyboardLayout(active_thread)
+        vks = [
+            self._to_vk(scan, layout)
+            for scan in range(len(state))]
+
+        for shift, ctrl, alt in itertools.product(
+                (False, True), (False, True), (False, True)):
+            current = [(None, False)] * len(state)
+            layout_data[(shift, ctrl, alt)] = current
+
+            # Update the keyboard state based on the modifier state
+            state[VK.SHIFT] = 0x80 if shift else 0x00
+            state[VK.CONTROL] = 0x80 if ctrl else 0x00
+            state[VK.MENU] = 0x80 if alt else 0x00
+
+            # For each virtual key code...
+            out = (ctypes.wintypes.WCHAR * 5)()
+            for (scan, vk) in enumerate(vks):
+                # ...translate it to a unicode character
+                count = self._ToUnicodeEx(
+                    vk, scan, ctypes.byref(state), ctypes.byref(out),
+                    len(out), 0, layout)
+
+                # Cache the result if a key is mapped
+                if count != 0:
+                    character = out[0]
+                    is_dead = count < 0
+                    current[scan] = (character, is_dead)
+
+                    # If the key is dead, flush the keyboard state
+                    if is_dead:
+                        self._ToUnicodeEx(
+                            vk, scan, ctypes.byref(state),
+                            ctypes.byref(out), len(out), 0, layout)
+
+        return (layout, layout_data)
+
+    def _to_scan(self, vk, layout):
+        """Retrieves the scan code for a virtual key code.
+
+        :param int vk: The virtual key code.
+
+        :param layout: The keyboard layout.
+
+        :return: the scan code
+        """
+        return self._MapVirtualKeyEx(
+            vk, self._MAPVK_VK_TO_VSC, layout)
+
+    def _to_vk(self, scan, layout):
+        """Retrieves the virtual key code for a scan code.
+
+        :param int vscan: The scan code.
+
+        :param layout: The keyboard layout.
+
+        :return: the virtual key code
+        """
+        return self._MapVirtualKeyEx(
+            scan, self._MAPVK_VSC_TO_VK, layout)
+
+    def _modifier_state(self):
+        """Returns a key into :attr:`_layout_data` for the current modifier
+        state.
+
+        :return: the current modifier state
+        """
+        shift = bool(self._GetAsyncKeyState(VK.SHIFT) & 0x8000)
+        ctrl = bool(self._GetAsyncKeyState(VK.CONTROL) & 0x8000)
+        alt = bool(self._GetAsyncKeyState(VK.MENU) & 0x8000)
+        return (shift, ctrl, alt)
+
+    @contextlib.contextmanager
+    def _thread_input(self):
+        """Yields the current thread ID.
+        """
+        yield GetCurrentThreadId()

myenv/lib/python3.10/site-packages/pynput/_util/win32_vks.py

@@ -0,0 +1,179 @@
+# coding: utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# pylint: disable=C0111,C0302
+
+LBUTTON = 1
+RBUTTON = 2
+CANCEL = 3
+MBUTTON = 4
+XBUTTON1 = 5
+XBUTTON2 = 6
+BACK = 8
+TAB = 9
+CLEAR = 12
+RETURN = 13
+SHIFT = 16
+CONTROL = 17
+MENU = 18
+PAUSE = 19
+CAPITAL = 20
+KANA = 21
+HANGEUL = 21
+HANGUL = 21
+JUNJA = 23
+FINAL = 24
+HANJA = 25
+KANJI = 25
+ESCAPE = 27
+CONVERT = 28
+NONCONVERT = 29
+ACCEPT = 30
+MODECHANGE = 31
+SPACE = 32
+PRIOR = 33
+NEXT = 34
+END = 35
+HOME = 36
+LEFT = 37
+UP = 38
+RIGHT = 39
+DOWN = 40
+SELECT = 41
+PRINT = 42
+EXECUTE = 43
+SNAPSHOT = 44
+INSERT = 45
+DELETE = 46
+HELP = 47
+LWIN = 91
+RWIN = 92
+APPS = 93
+SLEEP = 95
+NUMPAD0 = 96
+NUMPAD1 = 97
+NUMPAD2 = 98
+NUMPAD3 = 99
+NUMPAD4 = 100
+NUMPAD5 = 101
+NUMPAD6 = 102
+NUMPAD7 = 103
+NUMPAD8 = 104
+NUMPAD9 = 105
+MULTIPLY = 106
+ADD = 107
+SEPARATOR = 108
+SUBTRACT = 109
+DECIMAL = 110
+DIVIDE = 111
+F1 = 112
+F2 = 113
+F3 = 114
+F4 = 115
+F5 = 116
+F6 = 117
+F7 = 118
+F8 = 119
+F9 = 120
+F10 = 121
+F11 = 122
+F12 = 123
+F13 = 124
+F14 = 125
+F15 = 126
+F16 = 127
+F17 = 128
+F18 = 129
+F19 = 130
+F20 = 131
+F21 = 132
+F22 = 133
+F23 = 134
+F24 = 135
+NUMLOCK = 144
+SCROLL = 145
+OEM_NEC_EQUAL = 146
+OEM_FJ_JISHO = 146
+OEM_FJ_MASSHOU = 147
+OEM_FJ_TOUROKU = 148
+OEM_FJ_LOYA = 149
+OEM_FJ_ROYA = 150
+LSHIFT = 160
+RSHIFT = 161
+LCONTROL = 162
+RCONTROL = 163
+LMENU = 164
+RMENU = 165
+BROWSER_BACK = 166
+BROWSER_FORWARD = 167
+BROWSER_REFRESH = 168
+BROWSER_STOP = 169
+BROWSER_SEARCH = 170
+BROWSER_FAVORITES = 171
+BROWSER_HOME = 172
+VOLUME_MUTE = 173
+VOLUME_DOWN = 174
+VOLUME_UP = 175
+MEDIA_NEXT_TRACK = 176
+MEDIA_PREV_TRACK = 177
+MEDIA_STOP = 178
+MEDIA_PLAY_PAUSE = 179
+LAUNCH_MAIL = 180
+LAUNCH_MEDIA_SELECT = 181
+LAUNCH_APP1 = 182
+LAUNCH_APP2 = 183
+OEM_1 = 186
+OEM_PLUS = 187
+OEM_COMMA = 188
+OEM_MINUS = 189
+OEM_PERIOD = 190
+OEM_2 = 191
+OEM_3 = 192
+OEM_4 = 219
+OEM_5 = 220
+OEM_6 = 221
+OEM_7 = 222
+OEM_8 = 223
+OEM_AX = 225
+OEM_102 = 226
+ICO_HELP = 227
+ICO_00 = 228
+PROCESSKEY = 229
+ICO_CLEAR = 230
+PACKET = 231
+OEM_RESET = 233
+OEM_JUMP = 234
+OEM_PA1 = 235
+OEM_PA2 = 236
+OEM_PA3 = 237
+OEM_WSCTRL = 238
+OEM_CUSEL = 239
+OEM_ATTN = 240
+OEM_FINISH = 241
+OEM_COPY = 242
+OEM_AUTO = 243
+OEM_ENLW = 244
+OEM_BACKTAB = 245
+ATTN = 246
+CRSEL = 247
+EXSEL = 248
+EREOF = 249
+PLAY = 250
+ZOOM = 251
+NONAME = 252
+PA1 = 253
+OEM_CLEAR = 254

myenv/lib/python3.10/site-packages/pynput/_util/xorg.py

@@ -0,0 +1,496 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+Utility functions and classes for the *Xorg* backend.
+"""
+
+# pylint: disable=R0903
+# We implement stubs
+
+import contextlib
+import functools
+import itertools
+import operator
+import Xlib.display
+import Xlib.keysymdef
+import Xlib.threaded
+import Xlib.XK
+
+from . import AbstractListener
+from .xorg_keysyms import SYMBOLS
+
+
+# Create a display to verify that we have an X connection
+def _check_and_initialize():
+    display = Xlib.display.Display()
+    display.close()
+
+    for group in Xlib.keysymdef.__all__:
+        Xlib.XK.load_keysym_group(group)
+_check_and_initialize()
+del _check_and_initialize
+
+
+class X11Error(Exception):
+    """An error that is thrown at the end of a code block managed by a
+    :func:`display_manager` if an *X11* error occurred.
+    """
+    pass
+
+
+@contextlib.contextmanager
+def display_manager(display):
+    """Traps *X* errors and raises an :class:``X11Error`` at the end if any
+    error occurred.
+
+    This handler also ensures that the :class:`Xlib.display.Display` being
+    managed is sync'd.
+
+    :param Xlib.display.Display display: The *X* display.
+
+    :return: the display
+    :rtype: Xlib.display.Display
+    """
+    errors = []
+
+    def handler(*args):
+        """The *Xlib* error handler.
+        """
+        errors.append(args)
+
+    old_handler = display.set_error_handler(handler)
+    try:
+        yield display
+        display.sync()
+    finally:
+        display.set_error_handler(old_handler)
+    if errors:
+        raise X11Error(errors)
+
+
+def _find_mask(display, symbol):
+    """Returns the mode flags to use for a modifier symbol.
+
+    :param Xlib.display.Display display: The *X* display.
+
+    :param str symbol: The name of the symbol.
+
+    :return: the modifier mask
+    """
+    # Get the key code for the symbol
+    modifier_keycode = display.keysym_to_keycode(
+        Xlib.XK.string_to_keysym(symbol))
+
+    for index, keycodes in enumerate(display.get_modifier_mapping()):
+        for keycode in keycodes:
+            if keycode == modifier_keycode:
+                return 1 << index
+
+    return 0
+
+
+def alt_mask(display):
+    """Returns the *alt* mask flags.
+
+    The first time this function is called for a display, the value is cached.
+    Subsequent calls will return the cached value.
+
+    :param Xlib.display.Display display: The *X* display.
+
+    :return: the modifier mask
+    """
+    if not hasattr(display, '__alt_mask'):
+        display.__alt_mask = _find_mask(display, 'Alt_L')
+    return display.__alt_mask
+
+
+def alt_gr_mask(display):
+    """Returns the *alt* mask flags.
+
+    The first time this function is called for a display, the value is cached.
+    Subsequent calls will return the cached value.
+
+    :param Xlib.display.Display display: The *X* display.
+
+    :return: the modifier mask
+    """
+    if not hasattr(display, '__altgr_mask'):
+        display.__altgr_mask = _find_mask(display, 'Mode_switch')
+    return display.__altgr_mask
+
+
+def numlock_mask(display):
+    """Returns the *numlock* mask flags.
+
+    The first time this function is called for a display, the value is cached.
+    Subsequent calls will return the cached value.
+
+    :param Xlib.display.Display display: The *X* display.
+
+    :return: the modifier mask
+    """
+    if not hasattr(display, '__numlock_mask'):
+        display.__numlock_mask = _find_mask(display, 'Num_Lock')
+    return display.__numlock_mask
+
+
+def keysym_is_latin_upper(keysym):
+    """Determines whether a *keysym* is an upper case *latin* character.
+
+    This is true only if ``XK_A`` <= ``keysym`` <= ` XK_Z``.
+
+    :param in keysym: The *keysym* to check.
+    """
+    return Xlib.XK.XK_A <= keysym <= Xlib.XK.XK_Z
+
+
+def keysym_is_latin_lower(keysym):
+    """Determines whether a *keysym* is a lower case *latin* character.
+
+    This is true only if ``XK_a`` <= ``keysym`` <= ` XK_z``.
+
+    :param in keysym: The *keysym* to check.
+    """
+    return Xlib.XK.XK_a <= keysym <= Xlib.XK.XK_z
+
+
+def keysym_group(ks1, ks2):
+    """Generates a group from two *keysyms*.
+
+    The implementation of this function comes from:
+
+        Within each group, if the second element of the group is ``NoSymbol``,
+        then the group should be treated as if the second element were the same
+        as the first element, except when the first element is an alphabetic
+        *KeySym* ``K`` for which both lowercase and uppercase forms are
+        defined.
+
+        In that case, the group should be treated as if the first element were
+        the lowercase form of ``K`` and the second element were the uppercase
+        form of ``K``.
+
+    This function assumes that *alphabetic* means *latin*; this assumption
+    appears to be consistent with observations of the return values from
+    ``XGetKeyboardMapping``.
+
+    :param ks1: The first *keysym*.
+
+    :param ks2: The second *keysym*.
+
+    :return: a tuple conforming to the description above
+    """
+    if ks2 == Xlib.XK.NoSymbol:
+        if keysym_is_latin_upper(ks1):
+            return (Xlib.XK.XK_a + ks1 - Xlib.XK.XK_A, ks1)
+        elif keysym_is_latin_lower(ks1):
+            return (ks1, Xlib.XK.XK_A + ks1 - Xlib.XK.XK_a)
+        else:
+            return (ks1, ks1)
+    else:
+        return (ks1, ks2)
+
+
+def keysym_normalize(keysym):
+    """Normalises a list of *keysyms*.
+
+    The implementation of this function comes from:
+
+        If the list (ignoring trailing ``NoSymbol`` entries) is a single
+        *KeySym* ``K``, then the list is treated as if it were the list
+        ``K NoSymbol K NoSymbol``.
+
+        If the list (ignoring trailing ``NoSymbol`` entries) is a pair of
+        *KeySyms* ``K1 K2``, then the list is treated as if it were the list
+        ``K1 K2 K1 K2``.
+
+        If the list (ignoring trailing ``NoSymbol`` entries) is a triple of
+        *KeySyms* ``K1 K2 K3``, then the list is treated as if it were the list
+        ``K1 K2 K3 NoSymbol``.
+
+    This function will also group the *keysyms* using :func:`keysym_group`.
+
+    :param keysyms: A list of keysyms.
+
+    :return: the tuple ``(group_1, group_2)`` or ``None``
+    """
+    # Remove trailing NoSymbol
+    stripped = list(reversed(list(
+        itertools.dropwhile(
+            lambda n: n == Xlib.XK.NoSymbol,
+            reversed(keysym)))))
+
+    if not stripped:
+        return
+
+    elif len(stripped) == 1:
+        return (
+            keysym_group(stripped[0], Xlib.XK.NoSymbol),
+            keysym_group(stripped[0], Xlib.XK.NoSymbol))
+
+    elif len(stripped) == 2:
+        return (
+            keysym_group(stripped[0], stripped[1]),
+            keysym_group(stripped[0], stripped[1]))
+
+    elif len(stripped) == 3:
+        return (
+            keysym_group(stripped[0], stripped[1]),
+            keysym_group(stripped[2], Xlib.XK.NoSymbol))
+
+    elif len(stripped) >= 6:
+        # TODO: Find out why this is necessary; using only the documented
+        # behaviour may lead to only a US layout being used?
+        return (
+            keysym_group(stripped[0], stripped[1]),
+            keysym_group(stripped[4], stripped[5]))
+
+    else:
+        return (
+            keysym_group(stripped[0], stripped[1]),
+            keysym_group(stripped[2], stripped[3]))
+
+
+def index_to_shift(display, index):
+    """Converts an index in a *key code* list to the corresponding shift state.
+
+    :param Xlib.display.Display display: The display for which to retrieve the
+        shift mask.
+
+    :param int index: The keyboard mapping *key code* index.
+
+    :return: a shift mask
+    """
+    return (
+        (1 << 0 if index & 1 else 0) |
+        (alt_gr_mask(display) if index & 2 else 0))
+
+
+def shift_to_index(display, shift):
+    """Converts an index in a *key code* list to the corresponding shift state.
+
+    :param Xlib.display.Display display: The display for which to retrieve the
+        shift mask.
+
+    :param int index: The keyboard mapping *key code* index.
+
+    :return: a shift mask
+    """
+    return (
+        (1 if shift & 1 else 0) +
+        (2 if shift & alt_gr_mask(display) else 0))
+
+
+def keyboard_mapping(display):
+    """Generates a mapping from *keysyms* to *key codes* and required
+    modifier shift states.
+
+    :param Xlib.display.Display display: The display for which to retrieve the
+        keyboard mapping.
+
+    :return: the keyboard mapping
+    """
+    mapping = {}
+
+    shift_mask = 1 << 0
+    group_mask = alt_gr_mask(display)
+
+    # Iterate over all keysym lists in the keyboard mapping
+    min_keycode = display.display.info.min_keycode
+    keycode_count = display.display.info.max_keycode - min_keycode + 1
+    for index, keysyms in enumerate(display.get_keyboard_mapping(
+            min_keycode, keycode_count)):
+        key_code = index + min_keycode
+
+        # Normalise the keysym list to yield a tuple containing the two groups
+        normalized = keysym_normalize(keysyms)
+        if not normalized:
+            continue
+
+        # Iterate over the groups to extract the shift and modifier state
+        for groups, group in zip(normalized, (False, True)):
+            for keysym, shift in zip(groups, (False, True)):
+                if not keysym:
+                    continue
+                shift_state = 0 \
+                    | (shift_mask if shift else 0) \
+                    | (group_mask if group else 0)
+
+                # Prefer already known lesser shift states
+                if keysym in mapping and mapping[keysym][1] < shift_state:
+                    continue
+                mapping[keysym] = (key_code, shift_state)
+
+    return mapping
+
+
+def char_to_keysym(char):
+    """Converts a unicode character to a *keysym*.
+
+    :param str char: The unicode character.
+
+    :return: the corresponding *keysym*, or ``0`` if it cannot be found
+    """
+    ordinal = ord(char)
+    if ordinal < 0x100:
+        return ordinal
+    else:
+        return ordinal | 0x01000000
+
+
+def symbol_to_keysym(symbol):
+    """Converts a symbol name to a *keysym*.
+
+    :param str symbol: The name of the symbol.
+
+    :return: the corresponding *keysym*, or ``0`` if it cannot be found
+    """
+    # First try simple translation, the try a module attribute of
+    # Xlib.keysymdef.xkb and fall back on our pre-generated table
+    return (0
+        or Xlib.XK.string_to_keysym(symbol)
+        or getattr(Xlib.keysymdef.xkb, "XK_" + symbol, 0)
+        or SYMBOLS.get(symbol, (0,))[0])
+
+
+class ListenerMixin(object):
+    """A mixin for *X* event listeners.
+
+    Subclasses should set a value for :attr:`_EVENTS` and implement
+    :meth:`_handle_message`.
+    """
+    #: The events for which to listen
+    _EVENTS = tuple()
+
+    #: We use this instance for parsing the binary data
+    _EVENT_PARSER = Xlib.protocol.rq.EventField(None)
+
+    def _run(self):
+        self._display_stop = Xlib.display.Display()
+        self._display_record = Xlib.display.Display()
+        self._stopped = False
+        with display_manager(self._display_record) as dm:
+            self._context = dm.record_create_context(
+                0,
+                [Xlib.ext.record.AllClients],
+                [{
+                    'core_requests': (0, 0),
+                    'core_replies': (0, 0),
+                    'ext_requests': (0, 0, 0, 0),
+                    'ext_replies': (0, 0, 0, 0),
+                    'delivered_events': (0, 0),
+                    'device_events': self._EVENTS,
+                    'errors': (0, 0),
+                    'client_started': False,
+                    'client_died': False}])
+
+        # pylint: disable=W0702; we want to silence errors
+        try:
+            self._initialize(self._display_stop)
+            self._mark_ready()
+            if self.suppress:
+                with display_manager(self._display_stop) as dm:
+                    self._suppress_start(dm)
+            self._display_record.record_enable_context(
+                self._context, self._handler)
+        except:
+            # This exception will have been passed to the main thread
+            pass
+        finally:
+            if self.suppress:
+                with display_manager(self._display_stop) as dm:
+                    self._suppress_stop(dm)
+            self._display_stop.record_disable_context(self._context)
+            self._display_stop.flush()
+            self._display_record.record_free_context(self._context)
+            self._display_stop.close()
+            self._display_record.close()
+        # pylint: enable=W0702
+
+    def _stop_platform(self):
+        if not hasattr(self, '_context'):
+            self.wait()
+
+        # Do this asynchronously to avoid deadlocks
+        self._display_record.record_disable_context(self._context)
+
+    def _suppress_start(self, display):
+        """Starts suppressing events.
+
+        :param Xlib.display.Display display: The display for which to suppress
+            events.
+        """
+        raise NotImplementedError()
+
+    def _suppress_stop(self, display):
+        """Starts suppressing events.
+
+        :param Xlib.display.Display display: The display for which to suppress
+            events.
+        """
+        raise NotImplementedError()
+
+    @property
+    def _event_mask(self):
+        """The event mask.
+        """
+        return functools.reduce(operator.__or__, self._EVENTS, 0)
+
+    @AbstractListener._emitter
+    def _handler(self, events):
+        """The callback registered with *X* for mouse events.
+
+        This method will parse the response and call the callbacks registered
+        on initialisation.
+
+        :param events: The events passed by *X*. This is a binary block
+            parsable by :attr:`_EVENT_PARSER`.
+        """
+        if not self.running:
+            raise self.StopException()
+
+        data = events.data
+
+        while data and len(data):
+            event, data = self._EVENT_PARSER.parse_binary_value(
+                data, self._display_record.display, None, None)
+
+            injected = event.send_event
+            self._handle_message(self._display_stop, event, injected)
+
+    def _initialize(self, display):
+        """Initialises this listener.
+
+        This method is called immediately before the event loop, from the
+        handler thread.
+
+        :param display: The display being used.
+        """
+        pass
+
+    def _handle_message(self, display, event, injected):
+        """The device specific callback handler.
+
+        This method calls the appropriate callback registered when this
+        listener was created based on the event.
+
+        :param display: The display being used.
+
+        :param event: The event.
+
+        :param bool injected: Whether the event was injected.
+        """
+        pass

myenv/lib/python3.10/site-packages/pynput/keyboard/__init__.py

@@ -0,0 +1,249 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The module containing keyboard classes.
+
+See the documentation for more information.
+"""
+
+# pylint: disable=C0103
+# KeyCode, Key, Controller and Listener are not constants
+
+import itertools
+
+from pynput._util import backend, Events
+
+
+backend = backend(__name__)
+KeyCode = backend.KeyCode
+Key = backend.Key
+Controller = backend.Controller
+Listener = backend.Listener
+del backend
+
+
+# pylint: disable=C0326; it is easier to read column aligned keys
+#: The keys used as modifiers; the first value in each tuple is the
+#: base modifier to use for subsequent modifiers.
+_MODIFIER_KEYS = (
+    (Key.alt_gr, (Key.alt_gr.value,)),
+    (Key.alt,    (Key.alt.value,   Key.alt_l.value,   Key.alt_r.value)),
+    (Key.cmd,    (Key.cmd.value,   Key.cmd_l.value,   Key.cmd_r.value)),
+    (Key.ctrl,   (Key.ctrl.value,  Key.ctrl_l.value,  Key.ctrl_r.value)),
+    (Key.shift,  (Key.shift.value, Key.shift_l.value, Key.shift_r.value)))
+
+#: Normalised modifiers as a mapping from virtual key code to basic modifier.
+_NORMAL_MODIFIERS = {
+    value: key
+    for combination in _MODIFIER_KEYS
+    for key, value in zip(
+        itertools.cycle((combination[0],)),
+        combination[1])}
+
+#: Control codes to transform into key codes when typing
+_CONTROL_CODES = {
+    '\n': Key.enter,
+    '\r': Key.enter,
+    '\t': Key.tab}
+# pylint: enable=C0326
+
+
+class Events(Events):
+    """A keyboard event listener supporting synchronous iteration over the
+    events.
+
+    Possible events are:
+
+    :class:`Events.Press`
+        A key was pressed.
+
+    :class:`Events.Release`
+        A key was released.
+    """
+    _Listener = Listener
+
+    class Press(Events.Event):
+        """A key press event.
+        """
+        def __init__(self, key, injected):
+            #: The key.
+            self.key = key
+
+            #: Whether this event is synthetic.
+            self.injected = injected
+
+    class Release(Events.Event):
+        """A key release event.
+        """
+        def __init__(self, key, injected):
+            #: The key.
+            self.key = key
+
+            #: Whether this event is synthetic.
+            self.injected = injected
+
+    def __init__(self):
+        super(Events, self).__init__(
+            on_press=self.Press,
+            on_release=self.Release)
+
+
+class HotKey(object):
+    """A combination of keys acting as a hotkey.
+
+    This class acts as a container of hotkey state for a keyboard listener.
+
+    :param set keys: The collection of keys that must be pressed for this
+        hotkey to activate. Please note that a common limitation of the
+        hardware is that at most three simultaneously pressed keys are
+        supported, so using more keys may not work.
+
+    :param callable on_activate: The activation callback.
+    """
+    def __init__(self, keys, on_activate):
+        self._state = set()
+        self._keys = set(keys)
+        self._on_activate = on_activate
+
+    @staticmethod
+    def parse(keys):
+        """Parses a key combination string.
+
+        Key combination strings are sequences of key identifiers separated by
+        ``'+'``. Key identifiers are either single characters representing a
+        keyboard key, such as ``'a'``, or special key names identified by names
+        enclosed by brackets, such as ``'<ctrl>'``.
+
+        Keyboard keys are case-insensitive.
+
+        :raises ValueError: if a part of the keys string is invalid, or if it
+            contains multiple equal parts
+        """
+        def parts():
+            start = 0
+            for i, c in enumerate(keys):
+                if c == '+' and i != start:
+                    yield keys[start:i]
+                    start = i + 1
+            if start == len(keys):
+                raise ValueError(keys)
+            else:
+                yield keys[start:]
+
+        def parse(s):
+            if len(s) == 1:
+                return KeyCode.from_char(s.lower())
+            elif len(s) > 2 and (s[0], s[-1]) == ('<', '>'):
+                p = s[1:-1]
+                try:
+                    # We want to represent modifiers as Key instances, and all
+                    # other keys as KeyCodes
+                    key = Key[p.lower()]
+                    if key in _NORMAL_MODIFIERS.values():
+                        return key
+                    else:
+                        return KeyCode.from_vk(key.value.vk)
+                except KeyError:
+                    try:
+                        return KeyCode.from_vk(int(p))
+                    except ValueError:
+                        raise ValueError(s)
+            else:
+                raise ValueError(s)
+
+        # Split the string and parse the individual parts
+        raw_parts = list(parts())
+        parsed_parts = [
+            parse(s)
+            for s in raw_parts]
+
+        # Ensure no duplicate parts
+        if len(parsed_parts) != len(set(parsed_parts)):
+            raise ValueError(keys)
+        else:
+            return parsed_parts
+
+    def press(self, key):
+        """Updates the hotkey state for a pressed key.
+
+        If the key is not currently pressed, but is the last key for the full
+        combination, the activation callback will be invoked.
+
+        Please note that the callback will only be invoked once.
+
+        :param key: The key being pressed.
+        :type key: Key or KeyCode
+        """
+        if key in self._keys and key not in self._state:
+            self._state.add(key)
+            if self._state == self._keys:
+                self._on_activate()
+
+    def release(self, key):
+        """Updates the hotkey state for a released key.
+
+        :param key: The key being released.
+        :type key: Key or KeyCode
+        """
+        if key in self._state:
+            self._state.remove(key)
+
+
+class GlobalHotKeys(Listener):
+    """A keyboard listener supporting a number of global hotkeys.
+
+    This is a convenience wrapper to simplify registering a number of global
+    hotkeys.
+
+    :param dict hotkeys: A mapping from hotkey description to hotkey action.
+        Keys are strings passed to :meth:`HotKey.parse`.
+
+    :raises ValueError: if any hotkey description is invalid
+    """
+    def __init__(self, hotkeys, *args, **kwargs):
+        self._hotkeys = [
+            HotKey(HotKey.parse(key), value)
+            for key, value in hotkeys.items()]
+        super(GlobalHotKeys, self).__init__(
+            on_press=self._on_press,
+            on_release=self._on_release,
+            *args,
+            **kwargs)
+
+    def _on_press(self, key, injected):
+        """The press callback.
+
+        This is automatically registered upon creation.
+
+        :param key: The key provided by the base class.
+        :param injected: Whether the event was injected.
+        """
+        if not injected:
+            for hotkey in self._hotkeys:
+                hotkey.press(self.canonical(key))
+
+    def _on_release(self, key, injected):
+        """The release callback.
+
+        This is automatically registered upon creation.
+
+        :param key: The key provided by the base class.
+        :param injected: Whether the event was injected.
+        """
+        if not injected:
+            for hotkey in self._hotkeys:
+                hotkey.release(self.canonical(key))

myenv/lib/python3.10/site-packages/pynput/keyboard/_base.py

@@ -0,0 +1,754 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+This module contains the base implementation.
+
+The actual interface to keyboard classes is defined here, but the
+implementation is located in a platform dependent module.
+"""
+
+# pylint: disable=R0903
+# We implement stubs
+
+import contextlib
+import enum
+import threading
+import unicodedata
+
+import six
+
+from pynput._util import AbstractListener, prefix
+from pynput import _logger
+
+
+class KeyCode(object):
+    """
+    A :class:`KeyCode` represents the description of a key code used by the
+    operating system.
+    """
+    #: The names of attributes used as platform extensions.
+    _PLATFORM_EXTENSIONS = []
+
+    def __init__(self, vk=None, char=None, is_dead=False, **kwargs):
+        self.vk = vk
+        self.char = six.text_type(char) if char is not None else None
+        self.is_dead = is_dead
+
+        if self.is_dead:
+            try:
+                self.combining = unicodedata.lookup(
+                    'COMBINING ' + unicodedata.name(self.char))
+            except KeyError:
+                self.is_dead = False
+                self.combining = None
+            if self.is_dead and not self.combining:
+                raise KeyError(char)
+        else:
+            self.combining = None
+
+        for key in self._PLATFORM_EXTENSIONS:
+            setattr(self, key, kwargs.pop(key, None))
+        if kwargs:
+            raise ValueError(kwargs)
+
+
+    def __repr__(self):
+        if self.is_dead:
+            return '[%s]' % repr(self.char)
+        if self.char is not None:
+            return repr(self.char)
+        else:
+            return '<%d>' % self.vk
+
+    def __str__(self):
+        return repr(self)
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        if self.char is not None and other.char is not None:
+            return self.char == other.char and self.is_dead == other.is_dead
+        else:
+            return self.vk == other.vk and all(
+                getattr(self, f) == getattr(other, f)
+                for f in self._PLATFORM_EXTENSIONS)
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def join(self, key):
+        """Applies this dead key to another key and returns the result.
+
+        Joining a dead key with space (``' '``) or itself yields the non-dead
+        version of this key, if one exists; for example,
+        ``KeyCode.from_dead('~').join(KeyCode.from_char(' '))`` equals
+        ``KeyCode.from_char('~')`` and
+        ``KeyCode.from_dead('~').join(KeyCode.from_dead('~'))``.
+
+        :param KeyCode key: The key to join with this key.
+
+        :return: a key code
+
+        :raises ValueError: if the keys cannot be joined
+        """
+        # A non-dead key cannot be joined
+        if not self.is_dead:
+            raise ValueError(self)
+
+        # Joining two of the same keycodes, or joining with space, yields the
+        # non-dead version of the key
+        if key.char == ' ' or self == key:
+            return self.from_char(self.char)
+
+        # Otherwise we combine the characters
+        if key.char is not None:
+            combined = unicodedata.normalize(
+                'NFC',
+                key.char + self.combining)
+            if combined:
+                return self.from_char(combined)
+
+        raise ValueError(key)
+
+    @classmethod
+    def from_vk(cls, vk, **kwargs):
+        """Creates a key from a virtual key code.
+
+        :param vk: The virtual key code.
+
+        :param kwargs: Any other parameters to pass.
+
+        :return: a key code
+        """
+        return cls(vk=vk, **kwargs)
+
+    @classmethod
+    def from_char(cls, char, **kwargs):
+        """Creates a key from a character.
+
+        :param str char: The character.
+
+        :return: a key code
+        """
+        return cls(char=char, **kwargs)
+
+    @classmethod
+    def from_dead(cls, char, **kwargs):
+        """Creates a dead key.
+
+        :param char: The dead key. This should be the unicode character
+            representing the stand alone character, such as ``'~'`` for
+            *COMBINING TILDE*.
+
+        :return: a key code
+        """
+        return cls(char=char, is_dead=True, **kwargs)
+
+
+class Key(enum.Enum):
+    """A class representing various buttons that may not correspond to
+    letters. This includes modifier keys and function keys.
+
+    The actual values for these items differ between platforms. Some platforms
+    may have additional buttons, but these are guaranteed to be present
+    everywhere.
+    """
+    #: A generic Alt key. This is a modifier.
+    alt = KeyCode.from_vk(0)
+
+    #: The left Alt key. This is a modifier.
+    alt_l = KeyCode.from_vk(0)
+
+    #: The right Alt key. This is a modifier.
+    alt_r = KeyCode.from_vk(0)
+
+    #: The AltGr key. This is a modifier.
+    alt_gr = KeyCode.from_vk(0)
+
+    #: The Backspace key.
+    backspace = KeyCode.from_vk(0)
+
+    #: The CapsLock key.
+    caps_lock = KeyCode.from_vk(0)
+
+    #: A generic command button. On *PC* platforms, this corresponds to the
+    #: Super key or Windows key, and on *Mac* it corresponds to the Command
+    #: key. This may be a modifier.
+    cmd = KeyCode.from_vk(0)
+
+    #: The left command button. On *PC* platforms, this corresponds to the
+    #: Super key or Windows key, and on *Mac* it corresponds to the Command
+    #: key. This may be a modifier.
+    cmd_l = KeyCode.from_vk(0)
+
+    #: The right command button. On *PC* platforms, this corresponds to the
+    #: Super key or Windows key, and on *Mac* it corresponds to the Command
+    #: key. This may be a modifier.
+    cmd_r = KeyCode.from_vk(0)
+
+    #: A generic Ctrl key. This is a modifier.
+    ctrl = KeyCode.from_vk(0)
+
+    #: The left Ctrl key. This is a modifier.
+    ctrl_l = KeyCode.from_vk(0)
+
+    #: The right Ctrl key. This is a modifier.
+    ctrl_r = KeyCode.from_vk(0)
+
+    #: The Delete key.
+    delete = KeyCode.from_vk(0)
+
+    #: A down arrow key.
+    down = KeyCode.from_vk(0)
+
+    #: The End key.
+    end = KeyCode.from_vk(0)
+
+    #: The Enter or Return key.
+    enter = KeyCode.from_vk(0)
+
+    #: The Esc key.
+    esc = KeyCode.from_vk(0)
+
+    #: The function keys. F1 to F20 are defined.
+    f1 = KeyCode.from_vk(0)
+    f2 = KeyCode.from_vk(0)
+    f3 = KeyCode.from_vk(0)
+    f4 = KeyCode.from_vk(0)
+    f5 = KeyCode.from_vk(0)
+    f6 = KeyCode.from_vk(0)
+    f7 = KeyCode.from_vk(0)
+    f8 = KeyCode.from_vk(0)
+    f9 = KeyCode.from_vk(0)
+    f10 = KeyCode.from_vk(0)
+    f11 = KeyCode.from_vk(0)
+    f12 = KeyCode.from_vk(0)
+    f13 = KeyCode.from_vk(0)
+    f14 = KeyCode.from_vk(0)
+    f15 = KeyCode.from_vk(0)
+    f16 = KeyCode.from_vk(0)
+    f17 = KeyCode.from_vk(0)
+    f18 = KeyCode.from_vk(0)
+    f19 = KeyCode.from_vk(0)
+    f20 = KeyCode.from_vk(0)
+
+    #: The Home key.
+    home = KeyCode.from_vk(0)
+
+    #: A left arrow key.
+    left = KeyCode.from_vk(0)
+
+    #: The PageDown key.
+    page_down = KeyCode.from_vk(0)
+
+    #: The PageUp key.
+    page_up = KeyCode.from_vk(0)
+
+    #: A right arrow key.
+    right = KeyCode.from_vk(0)
+
+    #: A generic Shift key. This is a modifier.
+    shift = KeyCode.from_vk(0)
+
+    #: The left Shift key. This is a modifier.
+    shift_l = KeyCode.from_vk(0)
+
+    #: The right Shift key. This is a modifier.
+    shift_r = KeyCode.from_vk(0)
+
+    #: The Space key.
+    space = KeyCode.from_vk(0)
+
+    #: The Tab key.
+    tab = KeyCode.from_vk(0)
+
+    #: An up arrow key.
+    up = KeyCode.from_vk(0)
+
+    #: The play/pause toggle.
+    media_play_pause = KeyCode.from_vk(0)
+
+    #: The volume mute button.
+    media_volume_mute = KeyCode.from_vk(0)
+
+    #: The volume down button.
+    media_volume_down = KeyCode.from_vk(0)
+
+    #: The volume up button.
+    media_volume_up = KeyCode.from_vk(0)
+
+    #: The previous track button.
+    media_previous = KeyCode.from_vk(0)
+
+    #: The next track button.
+    media_next = KeyCode.from_vk(0)
+
+    #: The Insert key. This may be undefined for some platforms.
+    insert = KeyCode.from_vk(0)
+
+    #: The Menu key. This may be undefined for some platforms.
+    menu = KeyCode.from_vk(0)
+
+    #: The NumLock key. This may be undefined for some platforms.
+    num_lock = KeyCode.from_vk(0)
+
+    #: The Pause/Break key. This may be undefined for some platforms.
+    pause = KeyCode.from_vk(0)
+
+    #: The PrintScreen key. This may be undefined for some platforms.
+    print_screen = KeyCode.from_vk(0)
+
+    #: The ScrollLock key. This may be undefined for some platforms.
+    scroll_lock = KeyCode.from_vk(0)
+
+
+class Controller(object):
+    """A controller for sending virtual keyboard events to the system.
+    """
+    #: The virtual key codes
+    _KeyCode = KeyCode
+
+    #: The various keys.
+    _Key = Key
+
+    class InvalidKeyException(Exception):
+        """The exception raised when an invalid ``key`` parameter is passed to
+        either :meth:`Controller.press` or :meth:`Controller.release`.
+
+        Its first argument is the ``key`` parameter.
+        """
+        pass
+
+    class InvalidCharacterException(Exception):
+        """The exception raised when an invalid character is encountered in
+        the string passed to :meth:`Controller.type`.
+
+        Its first argument is the index of the character in the string, and the
+        second the character.
+        """
+        pass
+
+    def __init__(self):
+        self._log = _logger(self.__class__)
+        self._modifiers_lock = threading.RLock()
+        self._modifiers = set()
+        self._caps_lock = False
+        self._dead_key = None
+
+    def press(self, key):
+        """Presses a key.
+
+        A key may be either a string of length 1, one of the :class:`Key`
+        members or a :class:`KeyCode`.
+
+        Strings will be transformed to :class:`KeyCode` using
+        :meth:`KeyCode.char`. Members of :class:`Key` will be translated to
+        their :meth:`~Key.value`.
+
+        :param key: The key to press.
+
+        :raises InvalidKeyException: if the key is invalid
+
+        :raises ValueError: if ``key`` is a string, but its length is not ``1``
+        """
+        resolved = self._resolve(key)
+        if resolved is None:
+            raise self.InvalidKeyException(key)
+        self._update_modifiers(resolved, True)
+
+        # Update caps lock state
+        if resolved == self._Key.caps_lock.value:
+            self._caps_lock = not self._caps_lock
+
+        # If we currently have a dead key pressed, join it with this key
+        original = resolved
+        if self._dead_key:
+            try:
+                resolved = self._dead_key.join(resolved)
+            except ValueError:
+                self._handle(self._dead_key, True)
+                self._handle(self._dead_key, False)
+
+        # If the key is a dead key, keep it for later
+        if resolved.is_dead:
+            self._dead_key = resolved
+            return
+
+        try:
+            self._handle(resolved, True)
+        except self.InvalidKeyException:
+            if resolved != original:
+                self._handle(self._dead_key, True)
+                self._handle(self._dead_key, False)
+                self._handle(original, True)
+
+        self._dead_key = None
+
+    def release(self, key):
+        """Releases a key.
+
+        A key may be either a string of length 1, one of the :class:`Key`
+        members or a :class:`KeyCode`.
+
+        Strings will be transformed to :class:`KeyCode` using
+        :meth:`KeyCode.char`. Members of :class:`Key` will be translated to
+        their :meth:`~Key.value`.
+
+        :param key: The key to release. If this is a string, it is passed to
+            :meth:`touches` and the returned releases are used.
+
+        :raises InvalidKeyException: if the key is invalid
+
+        :raises ValueError: if ``key`` is a string, but its length is not ``1``
+        """
+        resolved = self._resolve(key)
+        if resolved is None:
+            raise self.InvalidKeyException(key)
+        self._update_modifiers(resolved, False)
+
+        # Ignore released dead keys
+        if resolved.is_dead:
+            return
+
+        self._handle(resolved, False)
+
+    def tap(self, key):
+        """Presses and releases a key.
+
+        This is equivalent to the following code::
+
+            controller.press(key)
+            controller.release(key)
+
+        :param key: The key to press.
+
+        :raises InvalidKeyException: if the key is invalid
+
+        :raises ValueError: if ``key`` is a string, but its length is not ``1``
+        """
+        self.press(key)
+        self.release(key)
+
+    def touch(self, key, is_press):
+        """Calls either :meth:`press` or :meth:`release` depending on the value
+        of ``is_press``.
+
+        :param key: The key to press or release.
+
+        :param bool is_press: Whether to press the key.
+
+        :raises InvalidKeyException: if the key is invalid
+        """
+        if is_press:
+            self.press(key)
+        else:
+            self.release(key)
+
+    @contextlib.contextmanager
+    def pressed(self, *args):
+        """Executes a block with some keys pressed.
+
+        :param keys: The keys to keep pressed.
+        """
+        for key in args:
+            self.press(key)
+
+        try:
+            yield
+        finally:
+            for key in reversed(args):
+                self.release(key)
+
+    def type(self, string):
+        """Types a string.
+
+        This method will send all key presses and releases necessary to type
+        all characters in the string.
+
+        :param str string: The string to type.
+
+        :raises InvalidCharacterException: if an untypable character is
+            encountered
+        """
+        from . import _CONTROL_CODES
+        for i, character in enumerate(string):
+            key = _CONTROL_CODES.get(character, character)
+            try:
+                self.press(key)
+                self.release(key)
+
+            except (ValueError, self.InvalidKeyException):
+                raise self.InvalidCharacterException(i, character)
+
+    @property
+    @contextlib.contextmanager
+    def modifiers(self):
+        """The currently pressed modifier keys.
+
+        Please note that this reflects only the internal state of this
+        controller, and not the state of the operating system keyboard buffer.
+        This property cannot be used to determine whether a key is physically
+        pressed.
+
+        Only the generic modifiers will be set; when pressing either
+        :attr:`Key.shift_l`, :attr:`Key.shift_r` or :attr:`Key.shift`, only
+        :attr:`Key.shift` will be present.
+
+        Use this property within a context block thus::
+
+            with controller.modifiers as modifiers:
+                with_block()
+
+        This ensures that the modifiers cannot be modified by another thread.
+        """
+        with self._modifiers_lock:
+            yield set(
+                self._as_modifier(modifier)
+                for modifier in self._modifiers)
+
+    @property
+    def alt_pressed(self):
+        """Whether any *alt* key is pressed.
+
+        Please note that this reflects only the internal state of this
+        controller. See :attr:`modifiers` for more information.
+        """
+        with self.modifiers as modifiers:
+            return self._Key.alt in modifiers
+
+    @property
+    def alt_gr_pressed(self):
+        """Whether *altgr* is pressed.
+
+        Please note that this reflects only the internal state of this
+        controller. See :attr:`modifiers` for more information.
+        """
+        with self.modifiers as modifiers:
+            return self._Key.alt_gr in modifiers
+
+    @property
+    def ctrl_pressed(self):
+        """Whether any *ctrl* key is pressed.
+
+        Please note that this reflects only the internal state of this
+        controller. See :attr:`modifiers` for more information.
+        """
+        with self.modifiers as modifiers:
+            return self._Key.ctrl in modifiers
+
+    @property
+    def shift_pressed(self):
+        """Whether any *shift* key is pressed, or *caps lock* is toggled.
+
+        Please note that this reflects only the internal state of this
+        controller. See :attr:`modifiers` for more information.
+        """
+        if self._caps_lock:
+            return True
+
+        with self.modifiers as modifiers:
+            return self._Key.shift in modifiers
+
+    def _resolve(self, key):
+        """Resolves a key to a :class:`KeyCode` instance.
+
+        This method will convert any key representing a character to uppercase
+        if a shift modifier is active.
+
+        :param key: The key to resolve.
+
+        :return: a key code, or ``None`` if it cannot be resolved
+        """
+        # Use the value for the key constants
+        if key in (k for k in self._Key):
+            return key.value
+
+        # Convert strings to key codes
+        if isinstance(key, six.string_types):
+            if len(key) != 1:
+                raise ValueError(key)
+            return self._KeyCode.from_char(key)
+
+        # Assume this is a proper key
+        if isinstance(key, self._KeyCode):
+            if key.char is not None and self.shift_pressed:
+                return self._KeyCode(vk=key.vk, char=key.char.upper())
+            else:
+                return key
+
+    def _update_modifiers(self, key, is_press):
+        """Updates the current modifier list.
+
+        If ``key`` is not a modifier, no action is taken.
+
+        :param key: The key being pressed or released.
+        """
+        # Check whether the key is a modifier
+        if self._as_modifier(key):
+            with self._modifiers_lock:
+                if is_press:
+                    self._modifiers.add(key)
+                else:
+                    try:
+                        self._modifiers.remove(key)
+                    except KeyError:
+                        pass
+
+    def _as_modifier(self, key):
+        """Returns a key as the modifier used internally if defined.
+
+        This method will convert values like :attr:`Key.alt_r.value` and
+        :attr:`Key.shift_l.value` to :attr:`Key.alt` and :attr:`Key.shift`.
+
+        :param key: The possible modifier key.
+
+        :return: the base modifier key, or ``None`` if ``key`` is not a
+            modifier
+        """
+        from . import _NORMAL_MODIFIERS
+        return _NORMAL_MODIFIERS.get(key, None)
+
+    def _handle(self, key, is_press):
+        """The platform implementation of the actual emitting of keyboard
+        events.
+
+        This is a platform dependent implementation.
+
+        :param Key key: The key to handle.
+
+        :param bool is_press: Whether this is a key press event.
+        """
+        raise NotImplementedError()
+
+
+# pylint: disable=W0223; This is also an abstract class
+class Listener(AbstractListener):
+    """A listener for keyboard events.
+
+    Instances of this class can be used as context managers. This is equivalent
+    to the following code::
+
+        listener.start()
+        try:
+            listener.wait()
+            with_statements()
+        finally:
+            listener.stop()
+
+    This class inherits from :class:`threading.Thread` and supports all its
+    methods. It will set :attr:`daemon` to ``True`` when created.
+
+    All callback arguments are optional; a callback may take less arguments
+    than actually passed, but not more, unless they are optional.
+
+    :param callable on_press: The callback to call when a button is pressed.
+
+        It will be called with the arguments ``(key, injected)``, where ``key``
+        is a :class:`KeyCode`, a :class:`Key` or ``None`` if the key is
+        unknown, and ``injected`` whether the event was injected and thus not
+        generated by an actual input device.
+
+        Please note that not all backends support ``injected`` and will always
+        set it to ``False``.
+
+    :param callable on_release: The callback to call when a button is released.
+
+        It will be called with the arguments ``(key, injected)``, where ``key``
+        is a :class:`KeyCode`, a :class:`Key` or ``None`` if the key is
+        unknown, and ``injected`` whether the event was injected and thus not
+        generated by an actual input device.
+
+        Please note that not all backends support ``injected`` and will always
+        set it to ``False``.
+
+    :param bool suppress: Whether to suppress events. Setting this to ``True``
+        will prevent the input events from being passed to the rest of the
+        system.
+
+    :param kwargs: Any non-standard platform dependent options. These should be
+        prefixed with the platform name thus: ``darwin_``, ``uinput_``,
+        ``xorg_`` or ``win32_``.
+
+        Supported values are:
+
+        ``darwin_intercept``
+            A callable taking the arguments ``(event_type, event)``, where
+            ``event_type`` is ``Quartz.kCGEventKeyDown`` or
+            ``Quartz.kCGEventKeyUp``, and ``event`` is a ``CGEventRef``.
+
+            This callable can freely modify the event using functions like
+            ``Quartz.CGEventSetIntegerValueField``. If this callable does not
+            return the event, the event is suppressed system wide.
+
+        ``uinput_device_paths``
+            A list of device paths.
+
+            If this is specified, *pynput* will limit the number of devices
+            checked for the capabilities needed to those passed, otherwise all
+            system devices will be used. Passing this might be required if an
+            incorrect device is chosen.
+
+        ``win32_event_filter``
+            A callable taking the arguments ``(msg, data)``, where ``msg`` is
+            the current message, and ``data`` associated data as a
+            `KBDLLHOOKSTRUCT <https://docs.microsoft.com/en-gb/windows/win32/api/winuser/ns-winuser-kbdllhookstruct>`_.
+
+            If this callback returns ``False``, the event will not be
+            propagated to the listener callback.
+
+            If ``self.suppress_event()`` is called, the event is suppressed
+            system wide.
+    """
+    def __init__(self, on_press=None, on_release=None, suppress=False,
+                 **kwargs):
+        self._log = _logger(self.__class__)
+        option_prefix = prefix(Listener, self.__class__)
+        self._options = {
+            key[len(option_prefix):]: value
+            for key, value in kwargs.items()
+            if key.startswith(option_prefix)}
+        super(Listener, self).__init__(
+            on_press=self._wrap(on_press, 2),
+            on_release=self._wrap(on_release, 2),
+            suppress=suppress)
+# pylint: enable=W0223
+
+    def canonical(self, key):
+        """Performs normalisation of a key.
+
+        This method attempts to convert key events to their canonical form, so
+        that events will equal regardless of modifier state.
+
+        This method will convert upper case keys to lower case keys, convert
+        any modifiers with a right and left version to the same value, and may
+        slow perform additional platform dependent normalisation.
+
+        :param key: The key to normalise.
+        :type key: Key or KeyCode
+
+        :return: a key
+        :rtype: Key or KeyCode
+        """
+        from pynput.keyboard import Key, KeyCode, _NORMAL_MODIFIERS
+        if isinstance(key, KeyCode) and key.char is not None:
+            return KeyCode.from_char(key.char.lower())
+        elif isinstance(key, Key) and key.value in _NORMAL_MODIFIERS:
+            return _NORMAL_MODIFIERS[key.value]
+        elif isinstance(key, Key) and key.value.vk is not None:
+            return KeyCode.from_vk(key.value.vk)
+        else:
+            return key

myenv/lib/python3.10/site-packages/pynput/keyboard/_darwin.py

@@ -0,0 +1,367 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The keyboard implementation for *macOS*.
+"""
+
+# pylint: disable=C0111
+# The documentation is extracted from the base classes
+
+# pylint: disable=R0903
+# We implement stubs
+
+import enum
+
+from Quartz import (
+    CGEventCreateKeyboardEvent,
+    CGEventGetFlags,
+    CGEventGetIntegerValueField,
+    CGEventGetType,
+    CGEventKeyboardGetUnicodeString,
+    CGEventKeyboardSetUnicodeString,
+    CGEventMaskBit,
+    CGEventPost,
+    CGEventSetFlags,
+    kCGEventFlagMaskAlternate,
+    kCGEventFlagMaskCommand,
+    kCGEventFlagMaskControl,
+    kCGEventFlagMaskShift,
+    kCGEventFlagsChanged,
+    kCGEventKeyDown,
+    kCGEventKeyUp,
+    kCGHIDEventTap,
+    kCGKeyboardEventKeycode,
+    NSEvent,
+    NSSystemDefined)
+
+from pynput._util.darwin import (
+    get_unicode_to_keycode_map,
+    keycode_context,
+    ListenerMixin)
+from pynput._util.darwin_vks import SYMBOLS
+from . import _base
+
+
+# From hidsystem/ev_keymap.h
+NX_KEYTYPE_PLAY = 16
+NX_KEYTYPE_MUTE = 7
+NX_KEYTYPE_SOUND_DOWN = 1
+NX_KEYTYPE_SOUND_UP = 0
+NX_KEYTYPE_NEXT = 17
+NX_KEYTYPE_PREVIOUS = 18
+NX_KEYTYPE_EJECT = 14
+
+# pylint: disable=C0103; We want to use the names from the C API
+# This is undocumented, but still widely known
+kSystemDefinedEventMediaKeysSubtype = 8
+
+# We extract this here since the name is very long
+otherEventWithType = getattr(
+        NSEvent,
+        'otherEventWithType_'
+        'location_'
+        'modifierFlags_'
+        'timestamp_'
+        'windowNumber_'
+        'context_'
+        'subtype_'
+        'data1_'
+        'data2_')
+# pylint: enable=C0103
+
+
+class KeyCode(_base.KeyCode):
+    _PLATFORM_EXTENSIONS = (
+        # Whether this is a media key
+        '_is_media',
+    )
+
+    # Be explicit about fields
+    _is_media = None
+
+    @classmethod
+    def _from_media(cls, vk, **kwargs):
+        """Creates a media key from a key code.
+
+        :param int vk: The key code.
+
+        :return: a key code
+        """
+        return cls.from_vk(vk, _is_media=True, **kwargs)
+
+    def _event(self, modifiers, mapping, is_pressed):
+        """This key as a *Quartz* event.
+
+        :param set modifiers: The currently active modifiers.
+
+        :param mapping: The current keyboard mapping.
+
+        :param bool is_press: Whether to generate a press event.
+
+        :return: a *Quartz* event
+        """
+        vk = self.vk or mapping.get(self.char)
+        if self._is_media:
+            result = otherEventWithType(
+                NSSystemDefined,
+                (0, 0),
+                0xa00 if is_pressed else 0xb00,
+                0,
+                0,
+                0,
+                8,
+                (self.vk << 16) | ((0xa if is_pressed else 0xb) << 8),
+                -1).CGEvent()
+        else:
+            result = CGEventCreateKeyboardEvent(
+                None, 0 if vk is None else vk, is_pressed)
+
+        CGEventSetFlags(
+            result,
+            0
+            | (kCGEventFlagMaskAlternate
+               if Key.alt in modifiers else 0)
+
+            | (kCGEventFlagMaskCommand
+               if Key.cmd in modifiers else 0)
+
+            | (kCGEventFlagMaskControl
+               if Key.ctrl in modifiers else 0)
+
+            | (kCGEventFlagMaskShift
+               if Key.shift in modifiers else 0))
+
+        if vk is None and self.char is not None:
+            CGEventKeyboardSetUnicodeString(
+                result, len(self.char), self.char)
+
+        return result
+
+
+# pylint: disable=W0212
+class Key(enum.Enum):
+    # Default keys
+    alt = KeyCode.from_vk(0x3A)
+    alt_l = KeyCode.from_vk(0x3A)
+    alt_r = KeyCode.from_vk(0x3D)
+    alt_gr = KeyCode.from_vk(0x3D)
+    backspace = KeyCode.from_vk(0x33)
+    caps_lock = KeyCode.from_vk(0x39)
+    cmd = KeyCode.from_vk(0x37)
+    cmd_l = KeyCode.from_vk(0x37)
+    cmd_r = KeyCode.from_vk(0x36)
+    ctrl = KeyCode.from_vk(0x3B)
+    ctrl_l = KeyCode.from_vk(0x3B)
+    ctrl_r = KeyCode.from_vk(0x3E)
+    delete = KeyCode.from_vk(0x75)
+    down = KeyCode.from_vk(0x7D)
+    end = KeyCode.from_vk(0x77)
+    enter = KeyCode.from_vk(0x24)
+    esc = KeyCode.from_vk(0x35)
+    f1 = KeyCode.from_vk(0x7A)
+    f2 = KeyCode.from_vk(0x78)
+    f3 = KeyCode.from_vk(0x63)
+    f4 = KeyCode.from_vk(0x76)
+    f5 = KeyCode.from_vk(0x60)
+    f6 = KeyCode.from_vk(0x61)
+    f7 = KeyCode.from_vk(0x62)
+    f8 = KeyCode.from_vk(0x64)
+    f9 = KeyCode.from_vk(0x65)
+    f10 = KeyCode.from_vk(0x6D)
+    f11 = KeyCode.from_vk(0x67)
+    f12 = KeyCode.from_vk(0x6F)
+    f13 = KeyCode.from_vk(0x69)
+    f14 = KeyCode.from_vk(0x6B)
+    f15 = KeyCode.from_vk(0x71)
+    f16 = KeyCode.from_vk(0x6A)
+    f17 = KeyCode.from_vk(0x40)
+    f18 = KeyCode.from_vk(0x4F)
+    f19 = KeyCode.from_vk(0x50)
+    f20 = KeyCode.from_vk(0x5A)
+    home = KeyCode.from_vk(0x73)
+    left = KeyCode.from_vk(0x7B)
+    page_down = KeyCode.from_vk(0x79)
+    page_up = KeyCode.from_vk(0x74)
+    right = KeyCode.from_vk(0x7C)
+    shift = KeyCode.from_vk(0x38)
+    shift_l = KeyCode.from_vk(0x38)
+    shift_r = KeyCode.from_vk(0x3C)
+    space = KeyCode.from_vk(0x31, char=' ')
+    tab = KeyCode.from_vk(0x30)
+    up = KeyCode.from_vk(0x7E)
+
+    media_play_pause = KeyCode._from_media(NX_KEYTYPE_PLAY)
+    media_volume_mute = KeyCode._from_media(NX_KEYTYPE_MUTE)
+    media_volume_down = KeyCode._from_media(NX_KEYTYPE_SOUND_DOWN)
+    media_volume_up = KeyCode._from_media(NX_KEYTYPE_SOUND_UP)
+    media_previous = KeyCode._from_media(NX_KEYTYPE_PREVIOUS)
+    media_next = KeyCode._from_media(NX_KEYTYPE_NEXT)
+    media_eject = KeyCode._from_media(NX_KEYTYPE_EJECT)
+# pylint: enable=W0212
+
+
+class Controller(_base.Controller):
+    _KeyCode = KeyCode
+    _Key = Key
+
+    def __init__(self):
+        super(Controller, self).__init__()
+        self._mapping = get_unicode_to_keycode_map()
+
+    def _handle(self, key, is_press):
+        with self.modifiers as modifiers:
+            CGEventPost(
+                kCGHIDEventTap,
+                (key if key not in (k for k in Key) else key.value)._event(
+                    modifiers, self._mapping, is_press))
+
+
+class Listener(ListenerMixin, _base.Listener):
+    #: The events that we listen to
+    _EVENTS = (
+        CGEventMaskBit(kCGEventKeyDown) |
+        CGEventMaskBit(kCGEventKeyUp) |
+        CGEventMaskBit(kCGEventFlagsChanged) |
+        CGEventMaskBit(NSSystemDefined)
+    )
+
+    # pylint: disable=W0212
+    #: A mapping from keysym to special key
+    _SPECIAL_KEYS = {
+        (key.value.vk, key.value._is_media): key
+        for key in Key}
+    # pylint: enable=W0212
+
+    #: The event flags set for the various modifier keys
+    _MODIFIER_FLAGS = {
+        Key.alt: kCGEventFlagMaskAlternate,
+        Key.alt_l: kCGEventFlagMaskAlternate,
+        Key.alt_r: kCGEventFlagMaskAlternate,
+        Key.cmd: kCGEventFlagMaskCommand,
+        Key.cmd_l: kCGEventFlagMaskCommand,
+        Key.cmd_r: kCGEventFlagMaskCommand,
+        Key.ctrl: kCGEventFlagMaskControl,
+        Key.ctrl_l: kCGEventFlagMaskControl,
+        Key.ctrl_r: kCGEventFlagMaskControl,
+        Key.shift: kCGEventFlagMaskShift,
+        Key.shift_l: kCGEventFlagMaskShift,
+        Key.shift_r: kCGEventFlagMaskShift}
+
+    def __init__(self, *args, **kwargs):
+        super(Listener, self).__init__(*args, **kwargs)
+        self._flags = 0
+        self._context = None
+        self._intercept = self._options.get(
+            'intercept',
+            None)
+
+    def _run(self):
+        with keycode_context() as context:
+            self._context = context
+            try:
+                super(Listener, self)._run()
+            finally:
+                self._context = None
+
+    def _handle_message(self, _proxy, event_type, event, _refcon, injected):
+        # Convert the event to a KeyCode; this may fail, and in that case we
+        # pass None
+        try:
+            key = self._event_to_key(event)
+        except IndexError:
+            key = None
+
+        try:
+            if event_type == kCGEventKeyDown:
+                # This is a normal key press
+                self.on_press(key, injected)
+
+            elif event_type == kCGEventKeyUp:
+                # This is a normal key release
+                self.on_release(key, injected)
+
+            elif key == Key.caps_lock:
+                # We only get an event when caps lock is toggled, so we fake
+                # press and release
+                self.on_press(key, injected)
+                self.on_release(key, injected)
+
+            elif event_type == NSSystemDefined:
+                sys_event = NSEvent.eventWithCGEvent_(event)
+                if sys_event.subtype() == kSystemDefinedEventMediaKeysSubtype:
+                    # The key in the special key dict; True since it is a media
+                    # key
+                    key = ((sys_event.data1() & 0xffff0000) >> 16, True)
+                    if key in self._SPECIAL_KEYS:
+                        flags = sys_event.data1() & 0x0000ffff
+                        is_press = ((flags & 0xff00) >> 8) == 0x0a
+                        if is_press:
+                            self.on_press(self._SPECIAL_KEYS[key])
+                        else:
+                            self.on_release(self._SPECIAL_KEYS[key])
+
+            else:
+                # This is a modifier event---excluding caps lock---for which we
+                # must check the current modifier state to determine whether
+                # the key was pressed or released
+                flags = CGEventGetFlags(event)
+                is_press = flags & self._MODIFIER_FLAGS.get(key, 0)
+                if is_press:
+                    self.on_press(key, injected)
+                else:
+                    self.on_release(key, injected)
+
+        finally:
+            # Store the current flag mask to be able to detect modifier state
+            # changes
+            self._flags = CGEventGetFlags(event)
+
+    def _event_to_key(self, event):
+        """Converts a *Quartz* event to a :class:`KeyCode`.
+
+        :param event: The event to convert.
+
+        :return: a :class:`pynput.keyboard.KeyCode`
+
+        :raises IndexError: if the key code is invalid
+        """
+        vk = CGEventGetIntegerValueField(
+            event, kCGKeyboardEventKeycode)
+        event_type = CGEventGetType(event)
+        is_media = True if event_type == NSSystemDefined else None
+
+        # First try special keys...
+        key = (vk, is_media)
+        if key in self._SPECIAL_KEYS:
+            return self._SPECIAL_KEYS[key]
+
+        # ...then try characters...
+        length, chars = CGEventKeyboardGetUnicodeString(
+            event, 100, None, None)
+        try:
+            printable = chars.isprintable()
+        except AttributeError:
+            printable = chars.isalnum()
+        if not printable and vk in SYMBOLS \
+                and CGEventGetFlags(event) \
+                & kCGEventFlagMaskControl:
+            return KeyCode.from_char(SYMBOLS[vk], vk=vk)
+        elif length > 0:
+            return KeyCode.from_char(chars, vk=vk)
+
+        # ...and fall back on a virtual key code
+        return KeyCode.from_vk(vk)

myenv/lib/python3.10/site-packages/pynput/keyboard/_dummy.py

@@ -0,0 +1,23 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+This module contains a dummy implementation.
+
+It cannot be used, but importing it will not raise any exceptions.
+"""
+
+from ._base import Controller, Key, KeyCode, Listener

myenv/lib/python3.10/site-packages/pynput/keyboard/_uinput.py

@@ -0,0 +1,446 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The keyboard implementation for *uinput*.
+"""
+
+# pylint: disable=C0111
+# The documentation is extracted from the base classes
+
+# pylint: disable=R0903
+# We implement stubs
+
+import enum
+import errno
+import functools
+import os
+import re
+import subprocess
+
+import evdev
+
+from evdev.events import KeyEvent
+
+from pynput._util import xorg_keysyms
+from pynput._util.uinput import ListenerMixin
+from . import _base
+
+
+class KeyCode(_base.KeyCode):
+    _PLATFORM_EXTENSIONS = (
+        # The name for this key
+        '_x_name',
+        '_kernel_name',
+    )
+
+    # Be explicit about fields
+    _x_name = None
+    _kernel_name = None
+# pylint: enable=W0212
+
+    @classmethod
+    def _from_name(cls, x_name, kernel_name, **kwargs):
+        """Creates a key from a name.
+
+        :param str x_name: The X name.
+
+        :param str kernel_name: The kernel name.
+
+        :return: a key code
+        """
+        try:
+            vk = getattr(evdev.ecodes, kernel_name)
+        except AttributeError:
+            vk = None
+        return cls.from_vk(
+            vk, _x_name=x_name, _kernel_name=kernel_name, **kwargs)
+
+
+# pylint: disable=W0212
+class Key(enum.Enum):
+    alt = KeyCode._from_name('Alt_L', 'KEY_LEFTALT')
+    alt_l = KeyCode._from_name('Alt_L', 'KEY_LEFTALT')
+    alt_r = KeyCode._from_name('Alt_R', 'KEY_RIGHTALT')
+    alt_gr = KeyCode._from_name('Mode_switch', 'KEY_RIGHTALT')
+    backspace = KeyCode._from_name('BackSpace', 'KEY_BACKSPACE')
+    caps_lock = KeyCode._from_name('Caps_Lock', 'KEY_CAPSLOCK')
+    cmd = KeyCode._from_name('Super_L', 'KEY_LEFTMETA')
+    cmd_l = KeyCode._from_name('Super_L', 'KEY_LEFTMETA')
+    cmd_r = KeyCode._from_name('Super_R', 'KEY_RIGHTMETA')
+    ctrl = KeyCode._from_name('Control_L', 'KEY_LEFTCTRL')
+    ctrl_l = KeyCode._from_name('Control_L', 'KEY_LEFTCTRL')
+    ctrl_r = KeyCode._from_name('Control_R', 'KEY_RIGHTCTRL')
+    delete = KeyCode._from_name('Delete', 'KEY_DELETE')
+    down = KeyCode._from_name('Down', 'KEY_DOWN')
+    end = KeyCode._from_name('End', 'KEY_END')
+    enter = KeyCode._from_name('Return', 'KEY_ENTER')
+    esc = KeyCode._from_name('Escape', 'KEY_ESC')
+    f1 = KeyCode._from_name('F1', 'KEY_F1')
+    f2 = KeyCode._from_name('F2', 'KEY_F2')
+    f3 = KeyCode._from_name('F3', 'KEY_F3')
+    f4 = KeyCode._from_name('F4', 'KEY_F4')
+    f5 = KeyCode._from_name('F5', 'KEY_F5')
+    f6 = KeyCode._from_name('F6', 'KEY_F6')
+    f7 = KeyCode._from_name('F7', 'KEY_F7')
+    f8 = KeyCode._from_name('F8', 'KEY_F8')
+    f9 = KeyCode._from_name('F9', 'KEY_F9')
+    f10 = KeyCode._from_name('F10', 'KEY_F10')
+    f11 = KeyCode._from_name('F11', 'KEY_F11')
+    f12 = KeyCode._from_name('F12', 'KEY_F12')
+    f13 = KeyCode._from_name('F13', 'KEY_F13')
+    f14 = KeyCode._from_name('F14', 'KEY_F14')
+    f15 = KeyCode._from_name('F15', 'KEY_F15')
+    f16 = KeyCode._from_name('F16', 'KEY_F16')
+    f17 = KeyCode._from_name('F17', 'KEY_F17')
+    f18 = KeyCode._from_name('F18', 'KEY_F18')
+    f19 = KeyCode._from_name('F19', 'KEY_F19')
+    f20 = KeyCode._from_name('F20', 'KEY_F20')
+    home = KeyCode._from_name('Home', 'KEY_HOME')
+    left = KeyCode._from_name('Left', 'KEY_LEFT')
+    page_down = KeyCode._from_name('Page_Down', 'KEY_PAGEDOWN')
+    page_up = KeyCode._from_name('Page_Up', 'KEY_PAGEUP')
+    right = KeyCode._from_name('Right', 'KEY_RIGHT')
+    shift = KeyCode._from_name('Shift_L', 'KEY_LEFTSHIFT')
+    shift_l = KeyCode._from_name('Shift_L', 'KEY_LEFTSHIFT')
+    shift_r = KeyCode._from_name('Shift_R', 'KEY_RIGHTSHIFT')
+    space = KeyCode._from_name('space', 'KEY_SPACE', char=' ')
+    tab = KeyCode._from_name('Tab', 'KEY_TAB', char='\t')
+    up = KeyCode._from_name('Up', 'KEY_UP')
+
+    media_play_pause = KeyCode._from_name('Play', 'KEY_PLAYPAUSE')
+    media_volume_mute = KeyCode._from_name('Mute', 'KEY_MUTE')
+    media_volume_down = KeyCode._from_name('LowerVolume', 'KEY_VOLUMEDOWN')
+    media_volume_up = KeyCode._from_name('RaiseVolume', 'KEY_VOLUMEUP')
+    media_previous = KeyCode._from_name('Prev', 'KEY_PREVIOUSSONG')
+    media_next = KeyCode._from_name('Next', 'KEY_NEXTSONG')
+
+    insert = KeyCode._from_name('Insert', 'KEY_INSERT')
+    menu = KeyCode._from_name('Menu', 'KEY_MENU')
+    num_lock = KeyCode._from_name('Num_Lock', 'KEY_NUMLOCK')
+    pause = KeyCode._from_name('Pause', 'KEY_PAUSE')
+    print_screen = KeyCode._from_name('Print', 'KEY_SYSRQ')
+    scroll_lock = KeyCode._from_name('Scroll_Lock', 'KEY_SCROLLLOCK')
+# pylint: enable=W0212
+
+
+class Layout(object):
+    """A description of the keyboard layout.
+    """
+    #: A regular expression to parse keycodes in the dumpkeys output
+    #:
+    #: The groups are: keycode number, key names.
+    KEYCODE_RE = re.compile(
+        r'keycode\s+(\d+)\s+=(.*)')
+
+    class Key(object):
+        """A key in a keyboard layout.
+        """
+        def __init__(self, normal, shifted, alt, alt_shifted):
+            self._values = (
+                normal,
+                shifted,
+                alt,
+                alt_shifted)
+
+        def __str__(self):
+            return ('<'
+                'normal: {}, '
+                'shifted: {}, '
+                'alternative: {}, '
+                'shifted alternative: {}>').format(
+                    self.normal, self.shifted, self.alt, self.alt_shifted)
+
+        __repr__ = __str__
+
+        def __iter__(self):
+            return iter(self._values)
+
+        def __getitem__(self, i):
+            return self._values[i]
+
+        @property
+        def normal(self):
+            """The normal key.
+            """
+            return self._values[0]
+
+        @property
+        def shifted(self):
+            """The shifted key.
+            """
+            return self._values[1]
+
+        @property
+        def alt(self):
+            """The alternative key.
+            """
+            return self._values[2]
+
+        @property
+        def alt_shifted(self):
+            """The shifted alternative key.
+            """
+            return self._values[3]
+
+    def __init__(self):
+        def as_char(k):
+            return k.value.char if isinstance(k, Key) else k.char
+        self._vk_table = self._load()
+        self._char_table = {
+            as_char(key): (
+                vk,
+                set()
+                    | {Key.shift} if i & 1 else set()
+                    | {Key.alt_gr} if i & 2 else set())
+            for vk, keys in self._vk_table.items()
+            for i, key in enumerate(keys)
+            if key is not None and as_char(key) is not None}
+
+    def for_vk(self, vk, modifiers):
+        """Reads a key for a virtual key code and modifier state.
+
+        :param int vk: The virtual key code.
+
+        :param set modifiers: A set of modifiers.
+
+        :return: a mapped key
+
+        :raises KeyError: if ``vk`` is an unknown key
+        """
+        return self._vk_table[vk][
+            0
+            | (1 if Key.shift in modifiers else 0)
+            | (2 if Key.alt_gr in modifiers else 0)]
+
+    def for_char(self, char):
+        """Reads a virtual key code and modifier state for a character.
+
+        :param str char: The character.
+
+        :return: the tuple ``(vk, modifiers)``
+
+        :raises KeyError: if ``vk`` is an unknown key
+        """
+        return self._char_table[char]
+
+    @functools.lru_cache()
+    def _load(self):
+        """Loads the keyboard layout.
+
+        For simplicity, we call out to the ``dumpkeys`` binary. In the future,
+        we may want to implement this ourselves.
+        """
+        result = {}
+        for keycode, names in self.KEYCODE_RE.findall(
+                subprocess.check_output(
+                    ['dumpkeys', '--full-table', '--keys-only']).decode('utf-8')):
+            vk = int(keycode)
+            keys = tuple(
+                self._parse(vk, name)
+                for name in names.split()[:4])
+            if any(key is not None for key in keys):
+                result[vk] = self.Key(*keys)
+        return result
+
+    def _parse(self, vk, name):
+        """Parses a single key from the ``dumpkeys`` output.
+
+        :param int vk: The key code.
+
+        :param str name: The key name.
+
+        :return: a key representation
+        """
+        try:
+            # First try special keys...
+            return next(
+                key
+                for key in Key
+                if key.value._x_name == name)
+        except StopIteration:
+            # ...then characters...
+            try:
+                _, char = xorg_keysyms.SYMBOLS[name.lstrip('+')]
+                if char:
+                    return KeyCode.from_char(char, vk=vk)
+            except KeyError:
+                pass
+
+            # ...and finally special dumpkeys names
+            try:
+                return KeyCode.from_char({
+                    'one': '1',
+                    'two': '2',
+                    'three': '3',
+                    'four': '4',
+                    'five': '5',
+                    'six': '6',
+                    'seven': '7',
+                    'eight': '8',
+                    'nine': '9',
+                    'zero': '0'}[name])
+            except KeyError:
+                pass
+
+
+class Controller(_base.Controller):
+    _KeyCode = KeyCode
+    _Key = Key
+
+    def __init__(self, *args, **kwargs):
+        super(Controller, self).__init__(*args, **kwargs)
+        self._layout = LAYOUT
+        self._dev = evdev.UInput()
+
+    def __del__(self):
+        if hasattr(self, '_dev'):
+            self._dev.close()
+
+    def _handle(self, key, is_press):
+        # Resolve the key to a virtual key code and a possible set of required
+        # modifiers
+        try:
+            vk, required_modifiers = self._to_vk_and_modifiers(key)
+        except ValueError:
+            raise self.InvalidKeyException(key)
+
+        # Determine how we need to modify the modifier state
+        if is_press and required_modifiers is not None:
+            with self.modifiers as modifiers:
+                vk, required_modifiers = self._layout.for_char(key.char)
+                to_press = {
+                    getattr(evdev.ecodes, key.value._kernel_name)
+                    for key in (required_modifiers - modifiers)}
+                to_release = {
+                    getattr(evdev.ecodes, key.value._kernel_name)
+                    for key in (modifiers - required_modifiers)}
+        else:
+            to_release = set()
+            to_press = set()
+
+        # Update the modifier state, send the key, and finally release any
+        # modifiers
+        cleanup = []
+        try:
+            for k in to_release:
+                self._send(k, False)
+                cleanup.append((k, True))
+            for k in to_press:
+                self._send(k, True)
+                cleanup.append((k, False))
+
+            self._send(vk, is_press)
+
+        finally:
+            for e in reversed(cleanup):
+                # pylint: disable E722; we want to suppress exceptions
+                try:
+                    self._send(*e)
+                except:
+                    pass
+                # pylint: enable E722
+
+            self._dev.syn()
+
+    def _to_vk_and_modifiers(self, key):
+        """Resolves a key to a virtual key code and a modifier set.
+
+        :param key: The key to resolve.
+        :type key: Key or KeyCode
+
+        :return: a virtual key code and possible required modifiers
+        """
+        if hasattr(key, 'vk') and key.vk is not None:
+            return (key.vk, None)
+        elif hasattr(key, 'char') and key.char is not None:
+            return self._layout.for_char(key.char)
+        else:
+            raise ValueError(key)
+
+    def _send(self, vk, is_press):
+        """Sends a virtual key event.
+
+        This method does not perform ``SYN``.
+
+        :param int vk: The virtual key.
+
+        :param bool is_press: Whether this is a press event.
+        """
+        self._dev.write(evdev.ecodes.EV_KEY, vk, int(is_press))
+
+
+class Listener(ListenerMixin, _base.Listener):
+    _EVENTS = (
+        evdev.ecodes.EV_KEY,)
+
+    #: A
+    _MODIFIERS = {
+        Key.alt.value.vk: Key.alt,
+        Key.alt_l.value.vk: Key.alt,
+        Key.alt_r.value.vk: Key.alt,
+        Key.alt_gr.value.vk: Key.alt_gr,
+        Key.shift.value.vk: Key.shift,
+        Key.shift_l.value.vk: Key.shift,
+        Key.shift_r.value.vk: Key.shift}
+
+    def __init__(self, *args, **kwargs):
+        super(Listener, self).__init__(*args, **kwargs)
+        self._layout = LAYOUT
+        self._modifiers = set()
+
+    def _handle_message(self, event):
+        is_press = event.value in (KeyEvent.key_down, KeyEvent.key_hold)
+        vk = event.code
+
+        # Update the modifier state
+        if vk in self._MODIFIERS:
+            modifier = self._MODIFIERS[vk]
+            if is_press:
+                self._modifiers.add(modifier)
+            elif modifier in self._modifiers:
+                self._modifiers.remove(modifier)
+
+        # Attempt to map the virtual key code to a key
+        try:
+            key = self._layout.for_vk(vk, self._modifiers)
+        except KeyError:
+            try:
+                key = next(
+                    key
+                    for key in Key
+                    if key.value.vk == vk)
+            except StopIteration:
+                key = KeyCode.from_vk(vk)
+
+        # We do not know whether these events are injected
+        if is_press:
+            self.on_press(key, False)
+        else:
+            self.on_release(key, False)
+
+
+try:
+    #: The keyboard layout.
+    LAYOUT = Layout()
+except subprocess.CalledProcessError as e:
+    raise ImportError('failed to load keyboard layout: "' + str(e) + (
+        '"; please make sure you are root' if os.getuid() != 1 else '"'))
+except OSError as e:
+    raise ImportError({
+        errno.ENOENT: 'the binary dumpkeys is not installed'}.get(
+            e.args[0],
+            str(e)))

myenv/lib/python3.10/site-packages/pynput/keyboard/_win32.py

@@ -0,0 +1,389 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The keyboard implementation for *Windows*.
+"""
+
+# pylint: disable=C0111
+# The documentation is extracted from the base classes
+
+# pylint: disable=R0903
+# We implement stubs
+
+import contextlib
+import ctypes
+import enum
+import six
+
+from ctypes import wintypes
+
+import pynput._util.win32_vks as VK
+
+from pynput._util import AbstractListener
+from pynput._util.win32 import (
+    INPUT,
+    INPUT_union,
+    KEYBDINPUT,
+    KeyTranslator,
+    ListenerMixin,
+    MapVirtualKey,
+    SendInput,
+    SystemHook,
+    VkKeyScan)
+from . import _base
+
+
+class KeyCode(_base.KeyCode):
+    _PLATFORM_EXTENSIONS = (
+        # Any extra flags.
+        '_flags',
+
+        #: The scan code.
+        '_scan',
+    )
+
+    # Be explicit about fields
+    _flags = None
+    _scan = None
+
+    def _parameters(self, is_press):
+        """The parameters to pass to ``SendInput`` to generate this key.
+
+        :param bool is_press: Whether to generate a press event.
+
+        :return: all arguments to pass to ``SendInput`` for this key
+
+        :rtype: dict
+
+        :raise ValueError: if this key is a unicode character that cannot be
+        represented by a single UTF-16 value
+        """
+        if self.vk:
+            vk = self.vk
+            scan = self._scan \
+                or MapVirtualKey(vk, MapVirtualKey.MAPVK_VK_TO_VSC)
+            flags = 0
+        elif ord(self.char) > 0xFFFF:
+            raise ValueError
+        else:
+            res = VkKeyScan(self.char)
+            if (res >> 8) & 0xFF == 0:
+                vk = res & 0xFF
+                scan = self._scan \
+                    or MapVirtualKey(vk, MapVirtualKey.MAPVK_VK_TO_VSC)
+                flags = 0
+            else:
+                vk = 0
+                scan = ord(self.char)
+                flags = KEYBDINPUT.UNICODE
+        state_flags = (KEYBDINPUT.KEYUP if not is_press else 0)
+        return dict(
+            dwFlags=(self._flags or 0) | flags | state_flags,
+            wVk=vk,
+            wScan=scan)
+
+    @classmethod
+    def _from_ext(cls, vk, **kwargs):
+        """Creates an extended key code.
+
+        :param vk: The virtual key code.
+
+        :param kwargs: Any other parameters to pass.
+
+        :return: a key code
+        """
+        return cls.from_vk(vk, _flags=KEYBDINPUT.EXTENDEDKEY, **kwargs)
+
+
+# pylint: disable=W0212
+class Key(enum.Enum):
+    alt = KeyCode.from_vk(VK.MENU)
+    alt_l = KeyCode.from_vk(VK.LMENU)
+    alt_r = KeyCode._from_ext(VK.RMENU)
+    alt_gr = KeyCode.from_vk(VK.RMENU)
+    backspace = KeyCode.from_vk(VK.BACK)
+    caps_lock = KeyCode.from_vk(VK.CAPITAL)
+    cmd = KeyCode.from_vk(VK.LWIN)
+    cmd_l = KeyCode.from_vk(VK.LWIN)
+    cmd_r = KeyCode.from_vk(VK.RWIN)
+    ctrl = KeyCode.from_vk(VK.CONTROL)
+    ctrl_l = KeyCode.from_vk(VK.LCONTROL)
+    ctrl_r = KeyCode._from_ext(VK.RCONTROL)
+    delete = KeyCode._from_ext(VK.DELETE)
+    down = KeyCode._from_ext(VK.DOWN)
+    end = KeyCode._from_ext(VK.END)
+    enter = KeyCode.from_vk(VK.RETURN)
+    esc = KeyCode.from_vk(VK.ESCAPE)
+    f1 = KeyCode.from_vk(VK.F1)
+    f2 = KeyCode.from_vk(VK.F2)
+    f3 = KeyCode.from_vk(VK.F3)
+    f4 = KeyCode.from_vk(VK.F4)
+    f5 = KeyCode.from_vk(VK.F5)
+    f6 = KeyCode.from_vk(VK.F6)
+    f7 = KeyCode.from_vk(VK.F7)
+    f8 = KeyCode.from_vk(VK.F8)
+    f9 = KeyCode.from_vk(VK.F9)
+    f10 = KeyCode.from_vk(VK.F10)
+    f11 = KeyCode.from_vk(VK.F11)
+    f12 = KeyCode.from_vk(VK.F12)
+    f13 = KeyCode.from_vk(VK.F13)
+    f14 = KeyCode.from_vk(VK.F14)
+    f15 = KeyCode.from_vk(VK.F15)
+    f16 = KeyCode.from_vk(VK.F16)
+    f17 = KeyCode.from_vk(VK.F17)
+    f18 = KeyCode.from_vk(VK.F18)
+    f19 = KeyCode.from_vk(VK.F19)
+    f20 = KeyCode.from_vk(VK.F20)
+    f21 = KeyCode.from_vk(VK.F21)
+    f22 = KeyCode.from_vk(VK.F22)
+    f23 = KeyCode.from_vk(VK.F23)
+    f24 = KeyCode.from_vk(VK.F24)
+    home = KeyCode._from_ext(VK.HOME)
+    left = KeyCode._from_ext(VK.LEFT)
+    page_down = KeyCode._from_ext(VK.NEXT)
+    page_up = KeyCode._from_ext(VK.PRIOR)
+    right = KeyCode._from_ext(VK.RIGHT)
+    shift = KeyCode.from_vk(VK.LSHIFT)
+    shift_l = KeyCode.from_vk(VK.LSHIFT)
+    shift_r = KeyCode.from_vk(VK.RSHIFT)
+    space = KeyCode.from_vk(VK.SPACE, char=' ')
+    tab = KeyCode.from_vk(VK.TAB)
+    up = KeyCode._from_ext(VK.UP)
+
+    media_play_pause = KeyCode._from_ext(VK.MEDIA_PLAY_PAUSE)
+    media_stop = KeyCode._from_ext(VK.MEDIA_STOP)
+    media_volume_mute = KeyCode._from_ext(VK.VOLUME_MUTE)
+    media_volume_down = KeyCode._from_ext(VK.VOLUME_DOWN)
+    media_volume_up = KeyCode._from_ext(VK.VOLUME_UP)
+    media_previous = KeyCode._from_ext(VK.MEDIA_PREV_TRACK)
+    media_next = KeyCode._from_ext(VK.MEDIA_NEXT_TRACK)
+
+    insert = KeyCode._from_ext(VK.INSERT)
+    menu = KeyCode.from_vk(VK.APPS)
+    num_lock = KeyCode._from_ext(VK.NUMLOCK)
+    pause = KeyCode.from_vk(VK.PAUSE)
+    print_screen = KeyCode._from_ext(VK.SNAPSHOT)
+    scroll_lock = KeyCode.from_vk(VK.SCROLL)
+# pylint: enable=W0212
+
+
+class Controller(_base.Controller):
+    _KeyCode = KeyCode
+    _Key = Key
+
+    def __init__(self, *args, **kwargs):
+        super(Controller, self).__init__(*args, **kwargs)
+
+    def _handle(self, key, is_press):
+        try:
+            SendInput(
+                1,
+                ctypes.byref(INPUT(
+                    type=INPUT.KEYBOARD,
+                    value=INPUT_union(
+                        ki=KEYBDINPUT(**key._parameters(is_press))))),
+                ctypes.sizeof(INPUT))
+        except ValueError:
+            # If key._parameters raises ValueError, the key is a unicode
+            # characters outsice of the range of a single UTF-16 value, and we
+            # must break it up into its surrogates
+            byte_data = bytearray(key.char.encode('utf-16le'))
+            surrogates = [
+                byte_data[i] | (byte_data[i + 1] << 8)
+                for i in range(0, len(byte_data), 2)]
+
+            state_flags = KEYBDINPUT.UNICODE \
+                | (KEYBDINPUT.KEYUP if not is_press else 0)
+
+            SendInput(
+                len(surrogates),
+                (INPUT * len(surrogates))(*(
+                    INPUT(
+                        INPUT.KEYBOARD,
+                        INPUT_union(
+                            ki=KEYBDINPUT(
+                                dwFlags=state_flags,
+                                wScan=scan)))
+                    for scan in surrogates)),
+                ctypes.sizeof(INPUT))
+
+
+class Listener(ListenerMixin, _base.Listener):
+    #: The Windows hook ID for low level keyboard events, ``WH_KEYBOARD_LL``
+    _EVENTS = 13
+
+    _WM_INPUTLANGCHANGE = 0x0051
+    _WM_KEYDOWN = 0x0100
+    _WM_KEYUP = 0x0101
+    _WM_SYSKEYDOWN = 0x0104
+    _WM_SYSKEYUP = 0x0105
+
+    # A bit flag attached to messages indicating that the payload is an actual
+    # UTF-16 character code
+    _UTF16_FLAG = 0x1000
+
+    # A bit flag attached to messages indicating that the event was injected
+    _INJECTED_FLAG = 0x2000
+
+    # A special virtual key code designating unicode characters
+    _VK_PACKET = 0xE7
+
+    #: The messages that correspond to a key press
+    _PRESS_MESSAGES = (_WM_KEYDOWN, _WM_SYSKEYDOWN)
+
+    #: The messages that correspond to a key release
+    _RELEASE_MESSAGES = (_WM_KEYUP, _WM_SYSKEYUP)
+
+    #: Additional window messages to propagate to the subclass handler.
+    _WM_NOTIFICATIONS = (
+        _WM_INPUTLANGCHANGE,
+    )
+
+    #: A mapping from keysym to special key
+    _SPECIAL_KEYS = {
+        key.value.vk: key
+        for key in Key}
+
+    _HANDLED_EXCEPTIONS = (
+        SystemHook.SuppressException,)
+
+    class _KBDLLHOOKSTRUCT(ctypes.Structure):
+        """Contains information about a mouse event passed to a
+        ``WH_KEYBOARD_LL`` hook procedure, ``LowLevelKeyboardProc``.
+        """
+        LLKHF_INJECTED = 0x00000010
+        LLKHF_LOWER_IL_INJECTED = 0x00000002
+        _fields_ = [
+            ('vkCode', wintypes.DWORD),
+            ('scanCode', wintypes.DWORD),
+            ('flags', wintypes.DWORD),
+            ('time', wintypes.DWORD),
+            ('dwExtraInfo', ctypes.c_void_p)]
+
+    #: A pointer to a :class:`KBDLLHOOKSTRUCT`
+    _LPKBDLLHOOKSTRUCT = ctypes.POINTER(_KBDLLHOOKSTRUCT)
+
+    def __init__(self, *args, **kwargs):
+        super(Listener, self).__init__(*args, **kwargs)
+        self._translator = KeyTranslator()
+        self._event_filter = self._options.get(
+            'event_filter',
+            lambda msg, data: True)
+
+    def _convert(self, code, msg, lpdata):
+        if code != SystemHook.HC_ACTION:
+            return
+
+        data = ctypes.cast(lpdata, self._LPKBDLLHOOKSTRUCT).contents
+        is_packet = data.vkCode == self._VK_PACKET
+        injected = (data.flags & (0
+            | self._KBDLLHOOKSTRUCT.LLKHF_INJECTED
+            | self._KBDLLHOOKSTRUCT.LLKHF_LOWER_IL_INJECTED)) != 0
+        message = (msg
+            | (self._UTF16_FLAG if is_packet else 0)
+            | (self._INJECTED_FLAG if injected else 0))
+
+        # Suppress further propagation of the event if it is filtered
+        if self._event_filter(msg, data) is False:
+            return None
+        elif is_packet:
+            return (message, data.scanCode)
+        else:
+            return (message, data.vkCode)
+
+    @AbstractListener._emitter
+    def _process(self, wparam, lparam):
+        msg = wparam
+        vk = lparam
+
+        # If the key has the UTF-16 flag, we treat it as a unicode character,
+        # otherwise convert the event to a KeyCode; this may fail, and in that
+        # case we pass None
+        is_utf16 = msg & self._UTF16_FLAG
+        injected = bool(msg & self._INJECTED_FLAG)
+        message = msg & ~(self._UTF16_FLAG | self._INJECTED_FLAG)
+        if is_utf16:
+            scan = vk
+            key = KeyCode.from_char(six.unichr(scan))
+        else:
+            try:
+                key = self._event_to_key(msg, vk)
+            except OSError:
+                key = None
+
+        if message in self._PRESS_MESSAGES:
+            self.on_press(key, injected)
+
+        elif message in self._RELEASE_MESSAGES:
+            self.on_release(key, injected)
+
+    # pylint: disable=R0201
+    @contextlib.contextmanager
+    def _receive(self):
+        """An empty context manager; we do not need to fake keyboard events.
+        """
+        yield
+    # pylint: enable=R0201
+
+    def _on_notification(self, code, wparam, lparam):
+        """Receives ``WM_INPUTLANGCHANGE`` and updates the cached layout.
+        """
+        if code == self._WM_INPUTLANGCHANGE:
+            self._translator.update_layout()
+
+    def _event_to_key(self, msg, vk):
+        """Converts an :class:`_KBDLLHOOKSTRUCT` to a :class:`KeyCode`.
+
+        :param msg: The message received.
+
+        :param vk: The virtual key code to convert.
+
+        :return: a :class:`pynput.keyboard.KeyCode`
+
+        :raises OSError: if the message and data could not be converted
+        """
+        # If the virtual key code corresponds to a Key value, we prefer that
+        if vk in self._SPECIAL_KEYS:
+            return self._SPECIAL_KEYS[vk]
+        else:
+            return KeyCode(**self._translate(
+                vk,
+                msg in self._PRESS_MESSAGES))
+
+    def _translate(self, vk, is_press):
+        """Translates a virtual key code to a parameter list passable to
+        :class:`pynput.keyboard.KeyCode`.
+
+        :param int vk: The virtual key code.
+
+        :param bool is_press: Whether this is a press event.
+
+        :return: a parameter list to the :class:`pynput.keyboard.KeyCode`
+            constructor
+        """
+        return self._translator(vk, is_press)
+
+    def canonical(self, key):
+        # If the key has a scan code, and we can find the character for it,
+        # return that, otherwise call the super class
+        scan = getattr(key, '_scan', None)
+        if scan is not None:
+            char = self._translator.char_from_scan(scan)
+            if char is not None:
+                return KeyCode.from_char(char)
+
+        return super(Listener, self).canonical(key)

myenv/lib/python3.10/site-packages/pynput/keyboard/_xorg.py

@@ -0,0 +1,667 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The keyboard implementation for *Xorg*.
+"""
+
+# pylint: disable=C0111
+# The documentation is extracted from the base classes
+
+# pylint: disable=R0903
+# We implement stubs
+
+# pylint: disable=W0611
+try:
+    import pynput._util.xorg
+except Exception as e:
+    raise ImportError('failed to acquire X connection: {}'.format(str(e)), e)
+# pylint: enable=W0611
+
+import enum
+import threading
+
+import Xlib.display
+import Xlib.ext
+import Xlib.ext.xtest
+import Xlib.X
+import Xlib.XK
+import Xlib.protocol
+import Xlib.keysymdef.xkb
+
+from pynput._util import NotifierMixin
+from pynput._util.xorg import (
+    alt_mask,
+    alt_gr_mask,
+    char_to_keysym,
+    display_manager,
+    index_to_shift,
+    keyboard_mapping,
+    ListenerMixin,
+    numlock_mask,
+    shift_to_index,
+    symbol_to_keysym)
+from pynput._util.xorg_keysyms import (
+    CHARS,
+    DEAD_KEYS,
+    KEYPAD_KEYS,
+    KEYSYMS,
+    SYMBOLS)
+from . import _base
+
+
+class KeyCode(_base.KeyCode):
+    _PLATFORM_EXTENSIONS = (
+        # The symbol name for this key
+        '_symbol',
+    )
+
+    # Be explicit about fields
+    _symbol = None
+
+    @classmethod
+    def _from_symbol(cls, symbol, **kwargs):
+        """Creates a key from a symbol.
+
+        :param str symbol: The symbol name.
+
+        :return: a key code
+        """
+        # First try simple translation
+        keysym = Xlib.XK.string_to_keysym(symbol)
+        if keysym:
+            return cls.from_vk(keysym, _symbol=symbol, **kwargs)
+
+        # If that fails, try checking a module attribute of Xlib.keysymdef.xkb
+        if not keysym:
+            # pylint: disable=W0702; we want to ignore errors
+            try:
+                symbol = 'XK_' + symbol
+                return cls.from_vk(
+                    getattr(Xlib.keysymdef.xkb, symbol, 0),
+                    _symbol=symbol,
+                    **kwargs)
+            except:
+                return cls.from_vk(
+                    SYMBOLS.get(symbol, (0,))[0],
+                    _symbol=symbol,
+                    **kwargs)
+            # pylint: enable=W0702
+
+    @classmethod
+    def _from_media(cls, name, **kwargs):
+        """Creates a media key from a partial name.
+
+        :param str name: The name. The actual symbol name will be this string
+            with ``'XF86_Audio'`` prepended.
+
+        :return: a key code
+        """
+        return cls._from_symbol('XF86_Audio' + name, **kwargs)
+
+
+# pylint: disable=W0212
+class Key(enum.Enum):
+    # Default keys
+    alt = KeyCode._from_symbol('Alt_L')
+    alt_l = KeyCode._from_symbol('Alt_L')
+    alt_r = KeyCode._from_symbol('Alt_R')
+    alt_gr = KeyCode._from_symbol('Mode_switch')
+    backspace = KeyCode._from_symbol('BackSpace')
+    caps_lock = KeyCode._from_symbol('Caps_Lock')
+    cmd = KeyCode._from_symbol('Super_L')
+    cmd_l = KeyCode._from_symbol('Super_L')
+    cmd_r = KeyCode._from_symbol('Super_R')
+    ctrl = KeyCode._from_symbol('Control_L')
+    ctrl_l = KeyCode._from_symbol('Control_L')
+    ctrl_r = KeyCode._from_symbol('Control_R')
+    delete = KeyCode._from_symbol('Delete')
+    down = KeyCode._from_symbol('Down')
+    end = KeyCode._from_symbol('End')
+    enter = KeyCode._from_symbol('Return')
+    esc = KeyCode._from_symbol('Escape')
+    f1 = KeyCode._from_symbol('F1')
+    f2 = KeyCode._from_symbol('F2')
+    f3 = KeyCode._from_symbol('F3')
+    f4 = KeyCode._from_symbol('F4')
+    f5 = KeyCode._from_symbol('F5')
+    f6 = KeyCode._from_symbol('F6')
+    f7 = KeyCode._from_symbol('F7')
+    f8 = KeyCode._from_symbol('F8')
+    f9 = KeyCode._from_symbol('F9')
+    f10 = KeyCode._from_symbol('F10')
+    f11 = KeyCode._from_symbol('F11')
+    f12 = KeyCode._from_symbol('F12')
+    f13 = KeyCode._from_symbol('F13')
+    f14 = KeyCode._from_symbol('F14')
+    f15 = KeyCode._from_symbol('F15')
+    f16 = KeyCode._from_symbol('F16')
+    f17 = KeyCode._from_symbol('F17')
+    f18 = KeyCode._from_symbol('F18')
+    f19 = KeyCode._from_symbol('F19')
+    f20 = KeyCode._from_symbol('F20')
+    home = KeyCode._from_symbol('Home')
+    left = KeyCode._from_symbol('Left')
+    page_down = KeyCode._from_symbol('Page_Down')
+    page_up = KeyCode._from_symbol('Page_Up')
+    right = KeyCode._from_symbol('Right')
+    shift = KeyCode._from_symbol('Shift_L')
+    shift_l = KeyCode._from_symbol('Shift_L')
+    shift_r = KeyCode._from_symbol('Shift_R')
+    space = KeyCode._from_symbol('space', char=' ')
+    tab = KeyCode._from_symbol('Tab')
+    up = KeyCode._from_symbol('Up')
+
+    media_play_pause = KeyCode._from_media('Play')
+    media_volume_mute = KeyCode._from_media('Mute')
+    media_volume_down = KeyCode._from_media('LowerVolume')
+    media_volume_up = KeyCode._from_media('RaiseVolume')
+    media_previous = KeyCode._from_media('Prev')
+    media_next = KeyCode._from_media('Next')
+
+    insert = KeyCode._from_symbol('Insert')
+    menu = KeyCode._from_symbol('Menu')
+    num_lock = KeyCode._from_symbol('Num_Lock')
+    pause = KeyCode._from_symbol('Pause')
+    print_screen = KeyCode._from_symbol('Print')
+    scroll_lock = KeyCode._from_symbol('Scroll_Lock')
+# pylint: enable=W0212
+
+
+class Controller(NotifierMixin, _base.Controller):
+    _KeyCode = KeyCode
+    _Key = Key
+
+    #: The shift mask for :attr:`Key.ctrl`
+    CTRL_MASK = Xlib.X.ControlMask
+
+    #: The shift mask for :attr:`Key.shift`
+    SHIFT_MASK = Xlib.X.ShiftMask
+
+    def __init__(self, *args, **kwargs):
+        super(Controller, self).__init__(*args, **kwargs)
+        self._display = Xlib.display.Display()
+        self._keyboard_mapping = None
+        self._borrows = {}
+        self._borrow_lock = threading.RLock()
+
+        # pylint: disable=C0103; this is treated as a class scope constant, but
+        # we cannot set it in the class scope, as it requires a Display instance
+        self.ALT_MASK = alt_mask(self._display)
+        self.ALT_GR_MASK = alt_gr_mask(self._display)
+        # pylint: enable=C0103
+
+    def __del__(self):
+        if hasattr(self, '_display'):
+            self._display.close()
+
+    @property
+    def keyboard_mapping(self):
+        """A mapping from *keysyms* to *key codes*.
+
+        Each value is the tuple ``(key_code, shift_state)``. By sending an
+        event with the specified *key code* and shift state, the specified
+        *keysym* will be touched.
+        """
+        if not self._keyboard_mapping:
+            self._update_keyboard_mapping()
+        return self._keyboard_mapping
+
+    def _handle(self, key, is_press):
+        """Resolves a key identifier and sends a keyboard event.
+
+        :param int key: The key to handle.
+        :param bool is_press: Whether this is a press.
+        """
+        event = Xlib.display.event.KeyPress if is_press \
+            else Xlib.display.event.KeyRelease
+        keysym = self._keysym(key)
+
+        # Make sure to verify that the key was resolved
+        if keysym is None:
+            raise self.InvalidKeyException(key)
+
+        # If the key has a virtual key code, use that immediately with
+        # fake_input; fake input,being an X server extension, has access to
+        # more internal state that we do
+        if key.vk is not None:
+            with display_manager(self._display) as dm:
+                Xlib.ext.xtest.fake_input(
+                    dm,
+                    Xlib.X.KeyPress if is_press else Xlib.X.KeyRelease,
+                    dm.keysym_to_keycode(key.vk))
+
+        # Otherwise use XSendEvent; we need to use this in the general case to
+        # work around problems with keyboard layouts
+        else:
+            try:
+                keycode, shift_state = self.keyboard_mapping[keysym]
+                self._send_key(event, keycode, shift_state)
+
+            except KeyError:
+                with self._borrow_lock:
+                    keycode, index, count = self._borrows[keysym]
+                    self._send_key(
+                        event,
+                        keycode,
+                        index_to_shift(self._display, index))
+                    count += 1 if is_press else -1
+                    self._borrows[keysym] = (keycode, index, count)
+
+        # Notify any running listeners
+        self._emit('_on_fake_event', key, is_press)
+
+    def _keysym(self, key):
+        """Converts a key to a *keysym*.
+
+        :param KeyCode key: The key code to convert.
+        """
+        return self._resolve_dead(key) if key.is_dead else None \
+            or self._resolve_special(key) \
+            or self._resolve_normal(key) \
+            or self._resolve_borrowed(key) \
+            or self._resolve_borrowing(key)
+
+    def _send_key(self, event, keycode, shift_state):
+        """Sends a single keyboard event.
+
+        :param event: The *X* keyboard event.
+
+        :param int keycode: The calculated keycode.
+
+        :param int shift_state: The shift state. The actual value used is
+            :attr:`shift_state` or'd with this value.
+        """
+        with display_manager(self._display) as dm, self.modifiers as modifiers:
+            # Under certain cimcumstances, such as when running under Xephyr,
+            # the value returned by dm.get_input_focus is an int
+            window = dm.get_input_focus().focus
+            send_event = getattr(
+                window,
+                'send_event',
+                lambda event: dm.send_event(window, event))
+            send_event(event(
+                detail=keycode,
+                state=shift_state | self._shift_mask(modifiers),
+                time=0,
+                root=dm.screen().root,
+                window=window,
+                same_screen=0,
+                child=Xlib.X.NONE,
+                root_x=0, root_y=0, event_x=0, event_y=0))
+
+    def _resolve_dead(self, key):
+        """Tries to resolve a dead key.
+
+        :param str identifier: The identifier to resolve.
+        """
+        # pylint: disable=W0702; we want to ignore errors
+        try:
+            keysym, _ = SYMBOLS[CHARS[key.combining]]
+        except:
+            return None
+        # pylint: enable=W0702
+
+        if keysym not in self.keyboard_mapping:
+            return None
+
+        return keysym
+
+    def _resolve_special(self, key):
+        """Tries to resolve a special key.
+
+        A special key has the :attr:`~KeyCode.vk` attribute set.
+
+        :param KeyCode key: The key to resolve.
+        """
+        if not key.vk:
+            return None
+
+        return key.vk
+
+    def _resolve_normal(self, key):
+        """Tries to resolve a normal key.
+
+        A normal key exists on the keyboard, and is typed by pressing
+        and releasing a simple key, possibly in combination with a modifier.
+
+        :param KeyCode key: The key to resolve.
+        """
+        keysym = self._key_to_keysym(key)
+        if keysym is None:
+            return None
+
+        if keysym not in self.keyboard_mapping:
+            return None
+
+        return keysym
+
+    def _resolve_borrowed(self, key):
+        """Tries to resolve a key by looking up the already borrowed *keysyms*.
+
+        A borrowed *keysym* does not exist on the keyboard, but has been
+        temporarily added to the layout.
+
+        :param KeyCode key: The key to resolve.
+        """
+        keysym = self._key_to_keysym(key)
+        if keysym is None:
+            return None
+
+        with self._borrow_lock:
+            if keysym not in self._borrows:
+                return None
+
+        return keysym
+
+    def _resolve_borrowing(self, key):
+        """Tries to resolve a key by modifying the layout temporarily.
+
+        A borrowed *keysym* does not exist on the keyboard, but is temporarily
+        added to the layout.
+
+        :param KeyCode key: The key to resolve.
+        """
+        keysym = self._key_to_keysym(key)
+        if keysym is None:
+            return None
+
+        mapping = self._display.get_keyboard_mapping(8, 255 - 8)
+
+        def i2kc(index):
+            return index + 8
+
+        def kc2i(keycode):
+            return keycode - 8
+
+        #: Finds a keycode and index by looking at already used keycodes
+        def reuse():
+            for _, (keycode, _, _) in self._borrows.items():
+                keycodes = mapping[kc2i(keycode)]
+
+                # Only the first four items are addressable by X
+                for index in range(4):
+                    if not keycodes[index]:
+                        return keycode, index
+
+        #: Finds a keycode and index by using a new keycode
+        def borrow():
+            for i, keycodes in enumerate(mapping):
+                if not any(keycodes):
+                    return i2kc(i), 0
+
+        #: Finds a keycode and index by reusing an old, unused one
+        def overwrite():
+            for keysym, (keycode, index, count) in self._borrows.items():
+                if count < 1:
+                    del self._borrows[keysym]
+                    return keycode, index
+
+        #: Registers a keycode for a specific key and modifier state
+        def register(dm, keycode, index):
+            i = kc2i(keycode)
+
+            # Check for use of empty mapping with a character that has upper
+            # and lower forms
+            lower = key.char.lower()
+            upper = key.char.upper()
+            if lower != upper and len(lower) == 1 and len(upper) == 1 and all(
+                    m == Xlib.XK.NoSymbol
+                    for m in mapping[i]):
+                lower = self._key_to_keysym(KeyCode.from_char(lower))
+                upper = self._key_to_keysym(KeyCode.from_char(upper))
+                if lower:
+                    mapping[i][0] = lower
+                    self._borrows[lower] = (keycode, 0, 0)
+                if upper:
+                    mapping[i][1] = upper
+                    self._borrows[upper] = (keycode, 1, 0)
+            else:
+                mapping[i][index] = keysym
+                self._borrows[keysym] = (keycode, index, 0)
+            dm.change_keyboard_mapping(keycode, mapping[i:i + 1])
+
+        try:
+            with display_manager(self._display) as dm, self._borrow_lock as _:
+                # First try an already used keycode, then try a new one, and
+                # fall back on reusing one that is not currently pressed
+                register(dm, *(
+                    reuse() or
+                    borrow() or
+                    overwrite()))
+            return keysym
+
+        except TypeError:
+            return None
+
+    def _key_to_keysym(self, key):
+        """Converts a character key code to a *keysym*.
+
+        :param KeyCode key: The key code.
+
+        :return: a keysym if found
+        :rtype: int or None
+        """
+        # If the key code already has a VK, simply return it
+        if key.vk is not None:
+            return key.vk
+
+        # If the character has no associated symbol, we try to map the
+        # character to a keysym
+        symbol = CHARS.get(key.char, None)
+        if symbol is None:
+            return char_to_keysym(key.char)
+
+        # Otherwise we attempt to convert the symbol to a keysym
+        # pylint: disable=W0702; we want to ignore errors
+        try:
+            return symbol_to_keysym(symbol)
+        except:
+            try:
+                return SYMBOLS[symbol][0]
+            except:
+                return None
+        # pylint: enable=W0702
+
+    def _shift_mask(self, modifiers):
+        """The *X* modifier mask to apply for a set of modifiers.
+
+        :param set modifiers: A set of active modifiers for which to get the
+            shift mask.
+        """
+        return (
+            0
+            | (self.ALT_MASK
+               if Key.alt in modifiers else 0)
+
+            | (self.ALT_GR_MASK
+               if Key.alt_gr in modifiers else 0)
+
+            | (self.CTRL_MASK
+               if Key.ctrl in modifiers else 0)
+
+            | (self.SHIFT_MASK
+               if Key.shift in modifiers else 0))
+
+    def _update_keyboard_mapping(self):
+        """Updates the keyboard mapping.
+        """
+        with display_manager(self._display) as dm:
+            self._keyboard_mapping = keyboard_mapping(dm)
+
+
+@Controller._receiver
+class Listener(ListenerMixin, _base.Listener):
+    _EVENTS = (
+        Xlib.X.KeyPress,
+        Xlib.X.KeyRelease)
+
+    #: A mapping from keysym to special key
+    _SPECIAL_KEYS = {
+        key.value.vk: key
+        for key in Key}
+
+    #: A mapping from numeric keypad keys to keys
+    _KEYPAD_KEYS = {
+        KEYPAD_KEYS['KP_0']: KeyCode.from_char('0'),
+        KEYPAD_KEYS['KP_1']: KeyCode.from_char('1'),
+        KEYPAD_KEYS['KP_2']: KeyCode.from_char('2'),
+        KEYPAD_KEYS['KP_3']: KeyCode.from_char('3'),
+        KEYPAD_KEYS['KP_4']: KeyCode.from_char('4'),
+        KEYPAD_KEYS['KP_5']: KeyCode.from_char('5'),
+        KEYPAD_KEYS['KP_6']: KeyCode.from_char('6'),
+        KEYPAD_KEYS['KP_7']: KeyCode.from_char('7'),
+        KEYPAD_KEYS['KP_8']: KeyCode.from_char('8'),
+        KEYPAD_KEYS['KP_9']: KeyCode.from_char('9'),
+        KEYPAD_KEYS['KP_Add']: KeyCode.from_char('+'),
+        KEYPAD_KEYS['KP_Decimal']: KeyCode.from_char(','),
+        KEYPAD_KEYS['KP_Delete']: Key.delete,
+        KEYPAD_KEYS['KP_Divide']: KeyCode.from_char('/'),
+        KEYPAD_KEYS['KP_Down']: Key.down,
+        KEYPAD_KEYS['KP_End']: Key.end,
+        KEYPAD_KEYS['KP_Enter']: Key.enter,
+        KEYPAD_KEYS['KP_Equal']: KeyCode.from_char('='),
+        KEYPAD_KEYS['KP_F1']: Key.f1,
+        KEYPAD_KEYS['KP_F2']: Key.f2,
+        KEYPAD_KEYS['KP_F3']: Key.f3,
+        KEYPAD_KEYS['KP_F4']: Key.f4,
+        KEYPAD_KEYS['KP_Home']: Key.home,
+        KEYPAD_KEYS['KP_Insert']: Key.insert,
+        KEYPAD_KEYS['KP_Left']: Key.left,
+        KEYPAD_KEYS['KP_Multiply']: KeyCode.from_char('*'),
+        KEYPAD_KEYS['KP_Page_Down']: Key.page_down,
+        KEYPAD_KEYS['KP_Page_Up']: Key.page_up,
+        KEYPAD_KEYS['KP_Right']: Key.right,
+        KEYPAD_KEYS['KP_Space']: Key.space,
+        KEYPAD_KEYS['KP_Subtract']: KeyCode.from_char('-'),
+        KEYPAD_KEYS['KP_Tab']: Key.tab,
+        KEYPAD_KEYS['KP_Up']: Key.up}
+
+    def __init__(self, *args, **kwargs):
+        super(Listener, self).__init__(*args, **kwargs)
+        self._keyboard_mapping = None
+
+    def _run(self):
+        with self._receive():
+            super(Listener, self)._run()
+
+    def _initialize(self, display):
+        # Get the keyboard mapping to be able to translate event details to
+        # key codes
+        min_keycode = display.display.info.min_keycode
+        keycode_count = display.display.info.max_keycode - min_keycode + 1
+        self._keyboard_mapping = display.get_keyboard_mapping(
+            min_keycode, keycode_count)
+
+    def _handle_message(self, display, event, injected):
+        # Convert the event to a KeyCode; this may fail, and in that case we
+        # pass None
+        try:
+            key = self._event_to_key(display, event)
+        except IndexError:
+            key = None
+
+        if event.type == Xlib.X.KeyPress:
+            self.on_press(key, injected)
+
+        elif event.type == Xlib.X.KeyRelease:
+            self.on_release(key, injected)
+
+    def _suppress_start(self, display):
+        display.screen().root.grab_keyboard(
+            self._event_mask, Xlib.X.GrabModeAsync, Xlib.X.GrabModeAsync,
+            Xlib.X.CurrentTime)
+
+    def _suppress_stop(self, display):
+        display.ungrab_keyboard(Xlib.X.CurrentTime)
+
+    def _on_fake_event(self, key, is_press):
+        """The handler for fake press events sent by the controllers.
+
+        :param KeyCode key: The key pressed.
+
+        :param bool is_press: Whether this is a press event.
+        """
+        (self.on_press if is_press else self.on_release)(
+            self._SPECIAL_KEYS.get(key.vk, key), True)
+
+    def _keycode_to_keysym(self, display, keycode, index):
+        """Converts a keycode and shift state index to a keysym.
+
+        This method uses a simplified version of the *X* convention to locate
+        the correct keysym in the display table: since this method is only used
+        to locate special keys, alphanumeric keys are not treated specially.
+
+        :param display: The current *X* display.
+
+        :param keycode: The keycode.
+
+        :param index: The shift state index.
+
+        :return: a keysym
+        """
+        keysym = display.keycode_to_keysym(keycode, index)
+        if keysym:
+            return keysym
+        elif index & 0x2:
+            return self._keycode_to_keysym(display, keycode, index & ~0x2)
+        elif index & 0x1:
+            return self._keycode_to_keysym(display, keycode, index & ~0x1)
+        else:
+            return 0
+
+    def _event_to_key(self, display, event):
+        """Converts an *X* event to a :class:`KeyCode`.
+
+        :param display: The current *X* display.
+
+        :param event: The event to convert.
+
+        :return: a :class:`pynput.keyboard.KeyCode`
+
+        :raises IndexError: if the key code is invalid
+        """
+        keycode = event.detail
+        index = shift_to_index(display, event.state)
+
+        # First try special keys...
+        keysym = self._keycode_to_keysym(display, keycode, index)
+        if keysym in self._SPECIAL_KEYS:
+            return self._SPECIAL_KEYS[keysym]
+        elif keysym in self._KEYPAD_KEYS:
+            # We must recalculate the index if numlock is active; index 1 is the
+            # one to use
+            try:
+                return self._KEYPAD_KEYS[
+                    self._keycode_to_keysym(
+                        display,
+                        keycode,
+                        bool(event.state & numlock_mask(display)))]
+            except KeyError:
+                # Since we recalculated the key, this may happen
+                pass
+
+        # ...then try characters...
+        name = KEYSYMS.get(keysym, None)
+        if name is not None and name in SYMBOLS:
+            char = SYMBOLS[name][1].upper() if index & 1 else SYMBOLS[name][1]
+            if char in DEAD_KEYS:
+                return KeyCode.from_dead(DEAD_KEYS[char], vk=keysym)
+            else:
+                return KeyCode.from_char(char, vk=keysym)
+
+        # ...and fall back on a virtual key code
+        return KeyCode.from_vk(keysym)

myenv/lib/python3.10/site-packages/pynput/mouse/__init__.py

@@ -0,0 +1,107 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The module containing mouse classes.
+
+See the documentation for more information.
+"""
+
+# pylint: disable=C0103
+# Button, Controller and Listener are not constants
+
+from pynput._util import backend, Events
+
+
+backend = backend(__name__)
+Button = backend.Button
+Controller = backend.Controller
+Listener = backend.Listener
+del backend
+
+
+class Events(Events):
+    """A mouse event listener supporting synchronous iteration over the events.
+
+    Possible events are:
+
+    :class:`Events.Move`
+        The mouse was moved.
+
+    :class:`Events.Click`
+        A mouse button was pressed or released.
+
+    :class:`Events.Scroll`
+        The device was scrolled.
+    """
+    _Listener = Listener
+
+    class Move(Events.Event):
+        """A move event.
+        """
+        def __init__(self, x, y, injected):
+            #: The X screen coordinate.
+            self.x = x
+
+            #: The Y screen coordinate.
+            self.y = y
+
+            #: Whether this event is synthetic.
+            self.injected = injected
+
+    class Click(Events.Event):
+        """A click event.
+        """
+        def __init__(self, x, y, button, pressed, injected):
+            #: The X screen coordinate.
+            self.x = x
+
+            #: The Y screen coordinate.
+            self.y = y
+
+            #: The button.
+            self.button = button
+
+            #: Whether the button was pressed.
+            self.pressed = pressed
+
+            #: Whether this event is synthetic.
+            self.injected = injected
+
+    class Scroll(Events.Event):
+        """A scroll event.
+        """
+        def __init__(self, x, y, dx, dy, injected):
+            #: The X screen coordinate.
+            self.x = x
+
+            #: The Y screen coordinate.
+            self.y = y
+
+            #: The number of horisontal steps.
+            self.dx = dx
+
+            #: The number of vertical steps.
+            self.dy = dy
+
+            #: Whether this event is synthetic.
+            self.injected = injected
+
+    def __init__(self):
+        super(Events, self).__init__(
+            on_move=self.Move,
+            on_click=self.Click,
+            on_scroll=self.Scroll)

myenv/lib/python3.10/site-packages/pynput/mouse/_base.py

@@ -0,0 +1,281 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+This module contains the base implementation.
+
+The actual interface to mouse classes is defined here, but the implementation
+is located in a platform dependent module.
+"""
+
+# pylint: disable=R0903
+# We implement stubs
+
+import enum
+
+from pynput._util import AbstractListener, prefix
+from pynput import _logger
+
+
+class Button(enum.Enum):
+    """The various buttons.
+
+    The actual values for these items differ between platforms. Some
+    platforms may have additional buttons, but these are guaranteed to be
+    present everywhere.
+    """
+    #: An unknown button was pressed
+    unknown = 0
+
+    #: The left button
+    left = 1
+
+    #: The middle button
+    middle = 2
+
+    #: The right button
+    right = 3
+
+
+class Controller(object):
+    """A controller for sending virtual mouse events to the system.
+    """
+    def __init__(self):
+        self._log = _logger(self.__class__)
+
+    @property
+    def position(self):
+        """The current position of the mouse pointer.
+
+        This is the tuple ``(x, y)``, and setting it will move the pointer.
+        """
+        return self._position_get()
+
+    @position.setter
+    def position(self, pos):
+        self._position_set(pos)
+
+    def scroll(self, dx, dy):
+        """Sends scroll events.
+
+        :param int dx: The horizontal scroll. The units of scrolling is
+            undefined.
+
+        :param int dy: The vertical scroll. The units of scrolling is
+            undefined.
+
+        :raises ValueError: if the values are invalid, for example out of
+            bounds
+        """
+        self._scroll(dx, dy)
+
+    def press(self, button):
+        """Emits a button press event at the current position.
+
+        :param Button button: The button to press.
+        """
+        self._press(button)
+
+    def release(self, button):
+        """Emits a button release event at the current position.
+
+        :param Button button: The button to release.
+        """
+        self._release(button)
+
+    def move(self, dx, dy):
+        """Moves the mouse pointer a number of pixels from its current
+        position.
+
+        :param int dx: The horizontal offset.
+
+        :param int dy: The vertical offset.
+
+        :raises ValueError: if the values are invalid, for example out of
+            bounds
+        """
+        self.position = tuple(sum(i) for i in zip(self.position, (dx, dy)))
+
+    def click(self, button, count=1):
+        """Emits a button click event at the current position.
+
+        The default implementation sends a series of press and release events.
+
+        :param Button button: The button to click.
+
+        :param int count: The number of clicks to send.
+        """
+        with self as controller:
+            for _ in range(count):
+                controller.press(button)
+                controller.release(button)
+
+    def __enter__(self):
+        """Begins a series of clicks.
+
+        In the default :meth:`click` implementation, the return value of this
+        method is used for the calls to :meth:`press` and :meth:`release`
+        instead of ``self``.
+
+        The default implementation is a no-op.
+        """
+        return self
+
+    def __exit__(self, exc_type, value, traceback):
+        """Ends a series of clicks.
+        """
+        pass
+
+    def _position_get(self):
+        """The implementation of the getter for :attr:`position`.
+
+        This is a platform dependent implementation.
+        """
+        raise NotImplementedError()
+
+    def _position_set(self, pos):
+        """The implementation of the setter for :attr:`position`.
+
+        This is a platform dependent implementation.
+        """
+        raise NotImplementedError()
+
+    def _scroll(self, dx, dy):
+        """The implementation of the :meth:`scroll` method.
+
+        This is a platform dependent implementation.
+        """
+        raise NotImplementedError()
+
+    def _press(self, button):
+        """The implementation of the :meth:`press` method.
+
+        This is a platform dependent implementation.
+        """
+        raise NotImplementedError()
+
+    def _release(self, button):
+        """The implementation of the :meth:`release` method.
+
+        This is a platform dependent implementation.
+        """
+        raise NotImplementedError()
+
+
+# pylint: disable=W0223; This is also an abstract class
+class Listener(AbstractListener):
+    """A listener for mouse events.
+
+    Instances of this class can be used as context managers. This is equivalent
+    to the following code::
+
+        listener.start()
+        try:
+            listener.wait()
+            with_statements()
+        finally:
+            listener.stop()
+
+    This class inherits from :class:`threading.Thread` and supports all its
+    methods. It will set :attr:`daemon` to ``True`` when created.
+
+    All callback arguments are optional; a callback may take less arguments
+    than actually passed, but not more, unless they are optional.
+
+    :param callable on_move: The callback to call when mouse move events occur.
+
+        It will be called with the arguments ``(x, y, injected)``, where ``(x,
+        y)`` is the new pointer position and ``injected`` whether the event was
+        injected and thus not generated by an actual input device. If this
+        callback raises :class:`StopException` or returns ``False``, the
+        listener is stopped.
+
+        Please note that not all backends support ``injected`` and will always
+        set it to ``False``.
+
+    :param callable on_click: The callback to call when a mouse button is
+        clicked.
+
+        It will be called with the arguments ``(x, y, button, pressed,
+        injected)``, where ``(x, y)`` is the new pointer position, ``button``
+        is one of the :class:`Button`, ``pressed`` is whether the button was
+        pressed and ``injected`` whether the event was injected and thus not
+        generated by an actual input device.
+
+        If this callback raises :class:`StopException` or returns ``False``,
+        the listener is stopped.
+
+        Please note that not all backends support ``injected`` and will always
+        set it to ``False``.
+
+    :param callable on_scroll: The callback to call when mouse scroll
+        events occur.
+
+        It will be called with the arguments ``(x, y, dx, dy, injected)``,
+        where ``(x, y)`` is the new pointer position, and ``(dx, dy)`` is the
+        scroll vector and ``injected`` whether the event was injected and thus
+        not generated by an actual input device.
+
+        If this callback raises :class:`StopException` or returns ``False``,
+        the listener is stopped.
+
+        Please note that not all backends support ``injected`` and will always
+        set it to ``False``.
+
+    :param bool suppress: Whether to suppress events. Setting this to ``True``
+        will prevent the input events from being passed to the rest of the
+        system.
+
+    :param kwargs: Any non-standard platform dependent options. These should be
+        prefixed with the platform name thus: ``darwin_``, ``xorg_`` or
+        ``win32_``.
+
+        Supported values are:
+
+        ``darwin_intercept``
+            A callable taking the arguments ``(event_type, event)``, where
+            ``event_type`` is any mouse related event type constant, and
+            ``event`` is a ``CGEventRef``.
+
+            This callable can freely modify the event using functions like
+            ``Quartz.CGEventSetIntegerValueField``. If this callable does not
+            return the event, the event is suppressed system wide.
+
+        ``win32_event_filter``
+            A callable taking the arguments ``(msg, data)``, where ``msg`` is
+            the current message, and ``data`` associated data as a
+            `MSLLHOOKSTRUCT <https://docs.microsoft.com/en-gb/windows/win32/api/winuser/ns-winuser-msllhookstruct>`_.
+
+            If this callback returns ``False``, the event will not
+            be propagated to the listener callback.
+
+            If ``self.suppress_event()`` is called, the event is suppressed
+            system wide.
+    """
+    def __init__(self, on_move=None, on_click=None, on_scroll=None,
+                 suppress=False, **kwargs):
+        self._log = _logger(self.__class__)
+        option_prefix = prefix(Listener, self.__class__)
+        self._options = {
+            key[len(option_prefix):]: value
+            for key, value in kwargs.items()
+            if key.startswith(option_prefix)}
+        super(Listener, self).__init__(
+            on_move=self._wrap(on_move, 3),
+            on_click=self._wrap(on_click, 5),
+            on_scroll=self._wrap(on_scroll, 5),
+            suppress=suppress)
+# pylint: enable=W0223

myenv/lib/python3.10/site-packages/pynput/mouse/_darwin.py

@@ -0,0 +1,212 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The mouse implementation for *macOS*.
+"""
+
+# pylint: disable=C0111
+# The documentation is extracted from the base classes
+
+# pylint: disable=R0903
+# We implement stubs
+
+import enum
+import Quartz
+
+from AppKit import NSEvent
+
+from pynput._util.darwin import (
+    ListenerMixin)
+from . import _base
+
+
+def _button_value(base_name, mouse_button):
+    """Generates the value tuple for a :class:`Button` value.
+
+    :param str base_name: The base name for the button. This should be a string
+        like ``'kCGEventLeftMouse'``.
+
+    :param int mouse_button: The mouse button ID.
+
+    :return: a value tuple
+    """
+    return (
+        tuple(
+            getattr(Quartz, '%sMouse%s' % (base_name, name))
+            for name in ('Down', 'Up', 'Dragged')),
+        mouse_button)
+
+
+class Button(enum.Enum):
+    """The various buttons.
+    """
+    unknown = None
+    left = _button_value('kCGEventLeft', 0)
+    middle = _button_value('kCGEventOther', 2)
+    right = _button_value('kCGEventRight', 1)
+
+
+class Controller(_base.Controller):
+    #: The scroll speed
+    _SCROLL_SPEED = 10
+
+    def __init__(self, *args, **kwargs):
+        super(Controller, self).__init__(*args, **kwargs)
+        self._click = None
+        self._drag_button = None
+
+    def _position_get(self):
+        pos = NSEvent.mouseLocation()
+
+        return pos.x, Quartz.CGDisplayPixelsHigh(0) - pos.y
+
+    def _position_set(self, pos):
+        try:
+            (_, _, mouse_type), mouse_button = self._drag_button.value
+        except AttributeError:
+            mouse_type = Quartz.kCGEventMouseMoved
+            mouse_button = 0
+
+        Quartz.CGEventPost(
+            Quartz.kCGHIDEventTap,
+            Quartz.CGEventCreateMouseEvent(
+                None,
+                mouse_type,
+                pos,
+                mouse_button))
+
+    def _scroll(self, dx, dy):
+        dx = int(dx)
+        dy = int(dy)
+
+        Quartz.CGEventPost(
+            Quartz.kCGHIDEventTap,
+            Quartz.CGEventCreateScrollWheelEvent(
+                None,
+                Quartz.kCGScrollEventUnitPixel,
+                2,
+                dy * self._SCROLL_SPEED,
+                dx * self._SCROLL_SPEED))
+
+    def _press(self, button):
+        (press, _, _), mouse_button = button.value
+        event = Quartz.CGEventCreateMouseEvent(
+            None,
+            press,
+            self.position,
+            mouse_button)
+
+        # If we are performing a click, we need to set this state flag
+        if self._click is not None:
+            self._click += 1
+            Quartz.CGEventSetIntegerValueField(
+                event,
+                Quartz.kCGMouseEventClickState,
+                self._click)
+
+        Quartz.CGEventPost(Quartz.kCGHIDEventTap, event)
+
+        # Store the button to enable dragging
+        self._drag_button = button
+
+    def _release(self, button):
+        (_, release, _), mouse_button = button.value
+        event = Quartz.CGEventCreateMouseEvent(
+            None,
+            release,
+            self.position,
+            mouse_button)
+
+        # If we are performing a click, we need to set this state flag
+        if self._click is not None:
+            Quartz.CGEventSetIntegerValueField(
+                event,
+                Quartz.kCGMouseEventClickState,
+                self._click)
+
+        Quartz.CGEventPost(Quartz.kCGHIDEventTap, event)
+
+        if button == self._drag_button:
+            self._drag_button = None
+
+    def __enter__(self):
+        self._click = 0
+        return self
+
+    def __exit__(self, exc_type, value, traceback):
+        self._click = None
+
+
+class Listener(ListenerMixin, _base.Listener):
+    #: The events that we listen to
+    _EVENTS = (
+        Quartz.CGEventMaskBit(Quartz.kCGEventMouseMoved) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventLeftMouseDown) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventLeftMouseUp) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventLeftMouseDragged) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventRightMouseDown) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventRightMouseUp) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventRightMouseDragged) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventOtherMouseDown) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventOtherMouseUp) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventOtherMouseDragged) |
+        Quartz.CGEventMaskBit(Quartz.kCGEventScrollWheel))
+
+    def __init__(self, *args, **kwargs):
+        super(Listener, self).__init__(*args, **kwargs)
+        self._intercept = self._options.get(
+            'intercept',
+            None)
+
+    def _handle_message(self, _proxy, event_type, event, _refcon, injected):
+        """The callback registered with *macOS* for mouse events.
+
+        This method will call the callbacks registered on initialisation.
+        """
+        try:
+            (px, py) = Quartz.CGEventGetLocation(event)
+        except AttributeError:
+            # This happens during teardown of the virtual machine
+            return
+
+        # Quickly detect the most common event type
+        if event_type == Quartz.kCGEventMouseMoved:
+            self.on_move(px, py, injected)
+
+        elif event_type == Quartz.kCGEventScrollWheel:
+            dx = Quartz.CGEventGetIntegerValueField(
+                event,
+                Quartz.kCGScrollWheelEventDeltaAxis2)
+            dy = Quartz.CGEventGetIntegerValueField(
+                event,
+                Quartz.kCGScrollWheelEventDeltaAxis1)
+            self.on_scroll(px, py, dx, dy, injected)
+
+        else:
+            for button in Button:
+                try:
+                    (press, release, drag), _ = button.value
+                except TypeError:
+                    # Button.unknown cannot be enumerated
+                    continue
+
+                # Press and release generate click events, and drag
+                # generates move events
+                if event_type in (press, release):
+                    self.on_click(px, py, button, event_type == press, injected)
+                elif event_type == drag:
+                    self.on_move(px, py, injected)

myenv/lib/python3.10/site-packages/pynput/mouse/_dummy.py

@@ -0,0 +1,22 @@
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+This module contains a dummy implementation.
+
+It cannot be used, but importing it will not raise any exceptions.
+"""
+
+from ._base import Button, Controller, Listener

myenv/lib/python3.10/site-packages/pynput/mouse/_win32.py

@@ -0,0 +1,226 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The mouse implementation for *Windows*.
+"""
+
+# pylint: disable=C0111
+# The documentation is extracted from the base classes
+
+# pylint: disable=R0903
+# We implement stubs
+
+import ctypes
+import enum
+
+from ctypes import (
+    windll,
+    wintypes)
+
+from pynput._util import NotifierMixin
+from pynput._util.win32 import (
+    INPUT,
+    INPUT_union,
+    ListenerMixin,
+    MOUSEINPUT,
+    SendInput,
+    SystemHook)
+from . import _base
+
+#: A constant used as a factor when constructing mouse scroll data.
+WHEEL_DELTA = 120
+
+
+class Button(enum.Enum):
+    """The various buttons.
+    """
+    unknown = None
+    left = (MOUSEINPUT.LEFTUP, MOUSEINPUT.LEFTDOWN, 0)
+    middle = (MOUSEINPUT.MIDDLEUP, MOUSEINPUT.MIDDLEDOWN, 0)
+    right = (MOUSEINPUT.RIGHTUP, MOUSEINPUT.RIGHTDOWN, 0)
+    x1 = (MOUSEINPUT.XUP, MOUSEINPUT.XDOWN, MOUSEINPUT.XBUTTON1)
+    x2 = (MOUSEINPUT.XUP, MOUSEINPUT.XDOWN, MOUSEINPUT.XBUTTON2)
+
+
+class Controller(NotifierMixin, _base.Controller):
+    __GetCursorPos = windll.user32.GetCursorPos
+    __SetCursorPos = windll.user32.SetCursorPos
+
+    def __init__(self, *args, **kwargs):
+        super(Controller, self).__init__(*args, **kwargs)
+
+    def _position_get(self):
+        point = wintypes.POINT()
+        if self.__GetCursorPos(ctypes.byref(point)):
+            return (point.x, point.y)
+        else:
+            return None
+
+    def _position_set(self, pos):
+        pos = int(pos[0]), int(pos[1])
+        self.__SetCursorPos(*pos)
+        self._emit('on_move', *pos, True)
+
+    def _scroll(self, dx, dy):
+        if dy:
+            SendInput(
+                1,
+                ctypes.byref(INPUT(
+                    type=INPUT.MOUSE,
+                    value=INPUT_union(
+                        mi=MOUSEINPUT(
+                            dwFlags=MOUSEINPUT.WHEEL,
+                            mouseData=int(dy * WHEEL_DELTA))))),
+                ctypes.sizeof(INPUT))
+
+        if dx:
+            SendInput(
+                1,
+                ctypes.byref(INPUT(
+                    type=INPUT.MOUSE,
+                    value=INPUT_union(
+                        mi=MOUSEINPUT(
+                            dwFlags=MOUSEINPUT.HWHEEL,
+                            mouseData=int(dx * WHEEL_DELTA))))),
+                ctypes.sizeof(INPUT))
+
+        if dx or dy:
+            px, py = self._position_get()
+            self._emit('on_scroll', px, py, dx, dy, True)
+
+    def _press(self, button):
+        SendInput(
+            1,
+            ctypes.byref(INPUT(
+                type=INPUT.MOUSE,
+                value=INPUT_union(
+                    mi=MOUSEINPUT(
+                        dwFlags=button.value[1],
+                        mouseData=button.value[2])))),
+            ctypes.sizeof(INPUT))
+
+    def _release(self, button):
+        SendInput(
+            1,
+            ctypes.byref(INPUT(
+                type=INPUT.MOUSE,
+                value=INPUT_union(
+                    mi=MOUSEINPUT(
+                        dwFlags=button.value[0],
+                        mouseData=button.value[2])))),
+            ctypes.sizeof(INPUT))
+
+
+@Controller._receiver
+class Listener(ListenerMixin, _base.Listener):
+    #: The Windows hook ID for low level mouse events, ``WH_MOUSE_LL``
+    _EVENTS = 14
+
+    WM_LBUTTONDOWN = 0x0201
+    WM_LBUTTONUP = 0x0202
+    WM_MBUTTONDOWN = 0x0207
+    WM_MBUTTONUP = 0x0208
+    WM_MOUSEMOVE = 0x0200
+    WM_MOUSEWHEEL = 0x020A
+    WM_MOUSEHWHEEL = 0x020E
+    WM_RBUTTONDOWN = 0x0204
+    WM_RBUTTONUP = 0x0205
+    WM_XBUTTONDOWN = 0x20B
+    WM_XBUTTONUP = 0x20C
+
+    MK_XBUTTON1 = 0x0020
+    MK_XBUTTON2 = 0x0040
+
+    XBUTTON1 = 1
+    XBUTTON2 = 2
+
+    #: A mapping from messages to button events
+    CLICK_BUTTONS = {
+        WM_LBUTTONDOWN: (Button.left, True),
+        WM_LBUTTONUP: (Button.left, False),
+        WM_MBUTTONDOWN: (Button.middle, True),
+        WM_MBUTTONUP: (Button.middle, False),
+        WM_RBUTTONDOWN: (Button.right, True),
+        WM_RBUTTONUP: (Button.right, False)}
+
+    #: A mapping from message to X button events.
+    X_BUTTONS = {
+        WM_XBUTTONDOWN: {
+            XBUTTON1: (Button.x1, True),
+            XBUTTON2: (Button.x2, True)},
+        WM_XBUTTONUP: {
+            XBUTTON1: (Button.x1, False),
+            XBUTTON2: (Button.x2, False)}}
+
+    #: A mapping from messages to scroll vectors
+    SCROLL_BUTTONS = {
+        WM_MOUSEWHEEL: (0, 1),
+        WM_MOUSEHWHEEL: (1, 0)}
+
+    _HANDLED_EXCEPTIONS = (
+        SystemHook.SuppressException,)
+
+    class _MSLLHOOKSTRUCT(ctypes.Structure):
+        """Contains information about a mouse event passed to a ``WH_MOUSE_LL``
+        hook procedure, ``MouseProc``.
+        """
+        LLMHF_INJECTED = 0x00000001
+        LLMHF_LOWER_IL_INJECTED = 0x00000002
+        _fields_ = [
+            ('pt', wintypes.POINT),
+            ('mouseData', wintypes.DWORD),
+            ('flags', wintypes.DWORD),
+            ('time', wintypes.DWORD),
+            ('dwExtraInfo', ctypes.c_void_p)]
+
+    #: A pointer to a :class:`_MSLLHOOKSTRUCT`
+    _LPMSLLHOOKSTRUCT = ctypes.POINTER(_MSLLHOOKSTRUCT)
+
+    def __init__(self, *args, **kwargs):
+        super(Listener, self).__init__(*args, **kwargs)
+        self._event_filter = self._options.get(
+            'event_filter',
+            lambda msg, data: True)
+
+    def _handle_message(self, code, msg, lpdata):
+        if code != SystemHook.HC_ACTION:
+            return
+
+        data = ctypes.cast(lpdata, self._LPMSLLHOOKSTRUCT).contents
+        injected = data.flags & (0
+            | self._MSLLHOOKSTRUCT.LLMHF_INJECTED
+            | self._MSLLHOOKSTRUCT.LLMHF_LOWER_IL_INJECTED) != 0
+
+        # Suppress further propagation of the event if it is filtered
+        if self._event_filter(msg, data) is False:
+            return
+
+        if msg == self.WM_MOUSEMOVE:
+            self.on_move(data.pt.x, data.pt.y,injected)
+
+        elif msg in self.CLICK_BUTTONS:
+            button, pressed = self.CLICK_BUTTONS[msg]
+            self.on_click(data.pt.x, data.pt.y, button, pressed, injected)
+
+        elif msg in self.X_BUTTONS:
+            button, pressed = self.X_BUTTONS[msg][data.mouseData >> 16]
+            self.on_click(data.pt.x, data.pt.y, button, pressed, injected)
+
+        elif msg in self.SCROLL_BUTTONS:
+            mx, my = self.SCROLL_BUTTONS[msg]
+            dd = wintypes.SHORT(data.mouseData >> 16).value // WHEEL_DELTA
+            self.on_scroll(data.pt.x, data.pt.y, dd * mx, dd * my, injected)

myenv/lib/python3.10/site-packages/pynput/mouse/_xorg.py

@@ -0,0 +1,184 @@
+# coding=utf-8
+# pynput
+# Copyright (C) 2015-2024 Moses Palmér
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+The keyboard implementation for *Xorg*.
+"""
+
+# pylint: disable=C0111
+# The documentation is extracted from the base classes
+
+
+# pylint: disable=E1101,E1102
+# We dynamically generate the Button class
+
+# pylint: disable=R0903
+# We implement stubs
+
+# pylint: disable=W0611
+try:
+    import pynput._util.xorg
+except Exception as e:
+    raise ImportError('failed to acquire X connection: {}'.format(str(e)), e)
+# pylint: enable=W0611
+
+import enum
+import Xlib.display
+import Xlib.ext
+import Xlib.ext.xtest
+import Xlib.X
+import Xlib.protocol
+
+from pynput._util.xorg import (
+    display_manager,
+    ListenerMixin)
+from . import _base
+
+
+# pylint: disable=C0103
+Button = enum.Enum(
+    'Button',
+    module=__name__,
+    names=[
+        ('unknown', None),
+        ('left', 1),
+        ('middle', 2),
+        ('right', 3),
+        ('scroll_up', 4),
+        ('scroll_down', 5),
+        ('scroll_left', 6),
+        ('scroll_right', 7)] + [
+            ('button%d' % i, i)
+            for i in range(8, 31)])
+# pylint: enable=C0103
+
+
+class Controller(_base.Controller):
+    def __init__(self, *args, **kwargs):
+        super(Controller, self).__init__(*args, **kwargs)
+        self._display = Xlib.display.Display()
+
+    def __del__(self):
+        if hasattr(self, '_display'):
+            self._display.close()
+
+    def _position_get(self):
+        with display_manager(self._display) as dm:
+            qp = dm.screen().root.query_pointer()
+            return (qp.root_x, qp.root_y)
+
+    def _position_set(self, pos):
+        px, py = self._check_bounds(*pos)
+        with display_manager(self._display) as dm:
+            Xlib.ext.xtest.fake_input(dm, Xlib.X.MotionNotify, x=px, y=py)
+
+    def _scroll(self, dx, dy):
+        dx, dy = self._check_bounds(dx, dy)
+        if dy:
+            self.click(
+                button=Button.scroll_up if dy > 0 else Button.scroll_down,
+                count=abs(dy))
+
+        if dx:
+            self.click(
+                button=Button.scroll_right if dx > 0 else Button.scroll_left,
+                count=abs(dx))
+
+    def _press(self, button):
+        with display_manager(self._display) as dm:
+            Xlib.ext.xtest.fake_input(dm, Xlib.X.ButtonPress, button.value)
+
+    def _release(self, button):
+        with display_manager(self._display) as dm:
+            Xlib.ext.xtest.fake_input(dm, Xlib.X.ButtonRelease, button.value)
+
+    def _check_bounds(self, *args):
+        """Checks the arguments and makes sure they are within the bounds of a
+        short integer.
+
+        :param args: The values to verify.
+        """
+        if not all(
+                (-0x7fff - 1) <= number <= 0x7fff
+                for number in args):
+            raise ValueError(args)
+        else:
+            return tuple(int(p) for p in args)
+
+
+class Listener(ListenerMixin, _base.Listener):
+    #: A mapping from button values to scroll directions
+    _SCROLL_BUTTONS = {
+        Button.scroll_up.value: (0, 1),
+        Button.scroll_down.value: (0, -1),
+        Button.scroll_right.value: (1, 0),
+        Button.scroll_left.value: (-1, 0)}
+
+    _EVENTS = (
+        Xlib.X.ButtonPressMask,
+        Xlib.X.ButtonReleaseMask)
+
+    def __init__(self, *args, **kwargs):
+        super(Listener, self).__init__(*args, **kwargs)
+
+    def _handle_message(self, dummy_display, event, injected):
+        px = event.root_x
+        py = event.root_y
+
+        if event.type == Xlib.X.ButtonPress:
+            # Scroll events are sent as button presses with the scroll
+            # button codes
+            scroll = self._SCROLL_BUTTONS.get(event.detail, None)
+            if scroll:
+                self.on_scroll(
+                    px, py, scroll[0], scroll[1], injected)
+            else:
+                self.on_click(
+                    px, py, self._button(event.detail), True, injected)
+
+        elif event.type == Xlib.X.ButtonRelease:
+            # Send an event only if this was not a scroll event
+            if event.detail not in self._SCROLL_BUTTONS:
+                self.on_click(
+                    px, py, self._button(event.detail), False, injected)
+
+        else:
+            self.on_move(px, py, injected)
+
+
+    def _suppress_start(self, display):
+        display.screen().root.grab_pointer(
+            True, self._event_mask, Xlib.X.GrabModeAsync, Xlib.X.GrabModeAsync,
+            0, 0, Xlib.X.CurrentTime)
+
+    def _suppress_stop(self, display):
+        display.ungrab_pointer(Xlib.X.CurrentTime)
+
+    # pylint: disable=R0201
+    def _button(self, detail):
+        """Creates a mouse button from an event detail.
+
+        If the button is unknown, :attr:`Button.unknown` is returned.
+
+        :param detail: The event detail.
+
+        :return: a button
+        """
+        try:
+            return Button(detail)
+        except ValueError:
+            return Button.unknown
+    # pylint: enable=R0201