././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617681733.332567 PyUserInput-0.1.12/0002755000174500001730000000000000000000000013561 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/MANIFEST.in0000644000174500001730000000001500000000000015311 0ustar00janitorsbuildinclude *.md ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617681733.332567 PyUserInput-0.1.12/PKG-INFO0000644000174500001730000001661400000000000014664 0ustar00janitorsbuildMetadata-Version: 1.0 Name: PyUserInput Version: 0.1.12 Summary: A simple, cross-platform module for mouse and keyboard control Home-page: https://github.com/PyUserInput/PyUserInput Author: Paul Barton , Pepijn de Vos Author-email: pablo.barton@gmail.com License: http://www.gnu.org/licenses/gpl-3.0.html Description: Deprecated =========== Please use [Pynput](https://github.com/moses-palmer/pynput) instead. What's wrong with PyUserInput? * Nobody is actively working on it * Events on Windows depend on PyHook which is dead and not compatible with Python 3 * Only works with QWERTY * Inconsistent API for non-printable characters * Probably more PyUserInput =========== A module for cross-platform control of the mouse and keyboard in python that is simple to use. Mouse control and capture should be fairly complete and mature on all supported platforms. Any incompatabilities should be reported. Basic keyboard handling should work, but known issues exist. Contributions welcome. For some less-common keyboard keys and layouts, you may want to look at [Pynput](https://github.com/moses-palmer/pynput) Installation ------------ ### Dependencies Depending on your platform, you will need the following python modules for PyUserInput to function: * Linux - Xlib (python-xlib) * Mac - Quartz, AppKit * Windows - pywin32, pyHook If you don't have the dependencies appropriate for your system, the installation of PyUserInput should warn you of that fact. ### Windows Dependencies PyUserInput on Windows depends on pywin32, a set of Windows extensions for Python. To install them, please visit http://sourceforge.net/projects/pywin32/files/pywin32/, choose the latest build, and download and run the file corresponding to your version and architecture of Python. ### Using pip PyUserInput is registered on PyPI (Python Package Index) and updated periodically, so tools such as pip or easy_install should work. `pip install PyUserInput` ### From Source You can download a [zip file from Github](https://github.com/PyUserInput/PyUserInput/archive/master.zip) or a tar.gz file from PyPI that contains the source code. Once you have uncompressed the file into a directory, you should navigate a terminal session to the directory that contains setup.py. The next step is to type the following command: `python setup.py install` If you are on linux and have a problem with permissions, you may need to prepend the command with sudo. For any other installation problems, open an issue on GitHub. How to get started ------------------ After installing PyUserInput, you should have pymouse and pykeyboard modules in your python path. Let's make a mouse and keyboard object: ```python from pymouse import PyMouse from pykeyboard import PyKeyboard m = PyMouse() k = PyKeyboard() ``` Here's an example of clicking the center of the screen and typing "Hello, World!": ```python x_dim, y_dim = m.screen_size() m.click(x_dim/2, y_dim/2, 1) k.type_string('Hello, World!') ``` PyKeyboard allows for a range of ways for sending keystrokes: ```python # pressing a key k.press_key('H') # which you then follow with a release of the key k.release_key('H') # or you can 'tap' a key which does both k.tap_key('e') # note that that tap_key does support a way of repeating keystrokes with a interval time between each k.tap_key('l',n=2,interval=5) # and you can send a string if needed too k.type_string('o World!') ``` and it supports a wide range of special keys: ```python #Create an Alt+Tab combo k.press_key(k.alt_key) k.tap_key(k.tab_key) k.release_key(k.alt_key) k.tap_key(k.function_keys[5]) # Tap F5 k.tap_key(k.numpad_keys['Home']) # Tap 'Home' on the numpad k.tap_key(k.numpad_keys[5], n=3) # Tap 5 on the numpad, thrice ``` Note you can also send multiple keystrokes together (e.g. when accessing a keyboard shortcut) using the press_keys method: ```python # Mac example k.press_keys(['Command','shift','3']) # Windows example k.press_keys([k.windows_l_key,'d']) ``` Consistency between platforms is a big challenge; Please look at the source for the operating system that you are using to help understand the format of the keys that you would need to send. For example: ```python # Windows k.tap_key(k.alt_key) # Mac k.tap_key('Alternate') ``` I'd like to make a special note about using PyMouseEvent and PyKeyboardEvent. These objects are a framework for listening for mouse and keyboard input; they don't do anything besides listen until you subclass them. I'm still formalizing PyKeyboardEvent, so here's an example of subclassing PyMouseEvent: ```python from pymouse import PyMouseEvent def fibo(): a = 0 yield a b = 1 yield b while True: a, b = b, a+b yield b class Clickonacci(PyMouseEvent): def __init__(self): PyMouseEvent.__init__(self) self.fibo = fibo() def click(self, x, y, button, press): '''Print Fibonacci numbers when the left click is pressed.''' if button == 1: if press: print(self.fibo.next()) else: # Exit if any other mouse button used self.stop() C = Clickonacci() C.run() ``` Intended Functionality of Capturing in PyUserInput -------------------------------------------------- For PyMouseEvent classes, the variables "capture" and "capture_move" may be passed during instantiation. If `capture=True` is passed, the intended result is that all mouse button input will go to your program and nowhere else. The same is true for `capture_move=True` except it deals with mouse pointer motion instead of the buttons. Both may be set simultaneously, and serve to prevent events from propagating further. If you notice any bugs with this behavior, please bring it to our attention. A Short Todo List ----------------- These are a few things I am considering for future development in PyUserInput: * Get rid of PyHook * Make PyKeyboard work for less-common keys and layouts * Make friends with more developers, help is needed... Keywords: mouse,keyboard user input event Platform: UNKNOWN ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617681733.332567 PyUserInput-0.1.12/PyUserInput.egg-info/0002755000174500001730000000000000000000000017522 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681733.0 PyUserInput-0.1.12/PyUserInput.egg-info/PKG-INFO0000644000174500001730000001661400000000000020625 0ustar00janitorsbuildMetadata-Version: 1.0 Name: PyUserInput Version: 0.1.12 Summary: A simple, cross-platform module for mouse and keyboard control Home-page: https://github.com/PyUserInput/PyUserInput Author: Paul Barton , Pepijn de Vos Author-email: pablo.barton@gmail.com License: http://www.gnu.org/licenses/gpl-3.0.html Description: Deprecated =========== Please use [Pynput](https://github.com/moses-palmer/pynput) instead. What's wrong with PyUserInput? * Nobody is actively working on it * Events on Windows depend on PyHook which is dead and not compatible with Python 3 * Only works with QWERTY * Inconsistent API for non-printable characters * Probably more PyUserInput =========== A module for cross-platform control of the mouse and keyboard in python that is simple to use. Mouse control and capture should be fairly complete and mature on all supported platforms. Any incompatabilities should be reported. Basic keyboard handling should work, but known issues exist. Contributions welcome. For some less-common keyboard keys and layouts, you may want to look at [Pynput](https://github.com/moses-palmer/pynput) Installation ------------ ### Dependencies Depending on your platform, you will need the following python modules for PyUserInput to function: * Linux - Xlib (python-xlib) * Mac - Quartz, AppKit * Windows - pywin32, pyHook If you don't have the dependencies appropriate for your system, the installation of PyUserInput should warn you of that fact. ### Windows Dependencies PyUserInput on Windows depends on pywin32, a set of Windows extensions for Python. To install them, please visit http://sourceforge.net/projects/pywin32/files/pywin32/, choose the latest build, and download and run the file corresponding to your version and architecture of Python. ### Using pip PyUserInput is registered on PyPI (Python Package Index) and updated periodically, so tools such as pip or easy_install should work. `pip install PyUserInput` ### From Source You can download a [zip file from Github](https://github.com/PyUserInput/PyUserInput/archive/master.zip) or a tar.gz file from PyPI that contains the source code. Once you have uncompressed the file into a directory, you should navigate a terminal session to the directory that contains setup.py. The next step is to type the following command: `python setup.py install` If you are on linux and have a problem with permissions, you may need to prepend the command with sudo. For any other installation problems, open an issue on GitHub. How to get started ------------------ After installing PyUserInput, you should have pymouse and pykeyboard modules in your python path. Let's make a mouse and keyboard object: ```python from pymouse import PyMouse from pykeyboard import PyKeyboard m = PyMouse() k = PyKeyboard() ``` Here's an example of clicking the center of the screen and typing "Hello, World!": ```python x_dim, y_dim = m.screen_size() m.click(x_dim/2, y_dim/2, 1) k.type_string('Hello, World!') ``` PyKeyboard allows for a range of ways for sending keystrokes: ```python # pressing a key k.press_key('H') # which you then follow with a release of the key k.release_key('H') # or you can 'tap' a key which does both k.tap_key('e') # note that that tap_key does support a way of repeating keystrokes with a interval time between each k.tap_key('l',n=2,interval=5) # and you can send a string if needed too k.type_string('o World!') ``` and it supports a wide range of special keys: ```python #Create an Alt+Tab combo k.press_key(k.alt_key) k.tap_key(k.tab_key) k.release_key(k.alt_key) k.tap_key(k.function_keys[5]) # Tap F5 k.tap_key(k.numpad_keys['Home']) # Tap 'Home' on the numpad k.tap_key(k.numpad_keys[5], n=3) # Tap 5 on the numpad, thrice ``` Note you can also send multiple keystrokes together (e.g. when accessing a keyboard shortcut) using the press_keys method: ```python # Mac example k.press_keys(['Command','shift','3']) # Windows example k.press_keys([k.windows_l_key,'d']) ``` Consistency between platforms is a big challenge; Please look at the source for the operating system that you are using to help understand the format of the keys that you would need to send. For example: ```python # Windows k.tap_key(k.alt_key) # Mac k.tap_key('Alternate') ``` I'd like to make a special note about using PyMouseEvent and PyKeyboardEvent. These objects are a framework for listening for mouse and keyboard input; they don't do anything besides listen until you subclass them. I'm still formalizing PyKeyboardEvent, so here's an example of subclassing PyMouseEvent: ```python from pymouse import PyMouseEvent def fibo(): a = 0 yield a b = 1 yield b while True: a, b = b, a+b yield b class Clickonacci(PyMouseEvent): def __init__(self): PyMouseEvent.__init__(self) self.fibo = fibo() def click(self, x, y, button, press): '''Print Fibonacci numbers when the left click is pressed.''' if button == 1: if press: print(self.fibo.next()) else: # Exit if any other mouse button used self.stop() C = Clickonacci() C.run() ``` Intended Functionality of Capturing in PyUserInput -------------------------------------------------- For PyMouseEvent classes, the variables "capture" and "capture_move" may be passed during instantiation. If `capture=True` is passed, the intended result is that all mouse button input will go to your program and nowhere else. The same is true for `capture_move=True` except it deals with mouse pointer motion instead of the buttons. Both may be set simultaneously, and serve to prevent events from propagating further. If you notice any bugs with this behavior, please bring it to our attention. A Short Todo List ----------------- These are a few things I am considering for future development in PyUserInput: * Get rid of PyHook * Make PyKeyboard work for less-common keys and layouts * Make friends with more developers, help is needed... Keywords: mouse,keyboard user input event Platform: UNKNOWN ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681733.0 PyUserInput-0.1.12/PyUserInput.egg-info/SOURCES.txt0000644000174500001730000000106000000000000021401 0ustar00janitorsbuildMANIFEST.in README.md setup.py ./pykeyboard/__init__.py ./pykeyboard/base.py ./pykeyboard/java_.py ./pykeyboard/mac.py ./pykeyboard/mir.py ./pykeyboard/wayland.py ./pykeyboard/windows.py ./pykeyboard/x11.py ./pykeyboard/x11_keysyms.py ./pymouse/__init__.py ./pymouse/base.py ./pymouse/java_.py ./pymouse/mac.py ./pymouse/mir.py ./pymouse/wayland.py ./pymouse/windows.py ./pymouse/x11.py PyUserInput.egg-info/PKG-INFO PyUserInput.egg-info/SOURCES.txt PyUserInput.egg-info/dependency_links.txt PyUserInput.egg-info/requires.txt PyUserInput.egg-info/top_level.txt././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681733.0 PyUserInput-0.1.12/PyUserInput.egg-info/dependency_links.txt0000644000174500001730000000000100000000000023566 0ustar00janitorsbuild ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681733.0 PyUserInput-0.1.12/PyUserInput.egg-info/requires.txt0000644000174500001730000000001400000000000022113 0ustar00janitorsbuildpython-xlib ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681733.0 PyUserInput-0.1.12/PyUserInput.egg-info/top_level.txt0000644000174500001730000000002300000000000022245 0ustar00janitorsbuildpykeyboard pymouse ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/README.md0000644000174500001730000001310100000000000015032 0ustar00janitorsbuildDeprecated =========== Please use [Pynput](https://github.com/moses-palmer/pynput) instead. What's wrong with PyUserInput? * Nobody is actively working on it * Events on Windows depend on PyHook which is dead and not compatible with Python 3 * Only works with QWERTY * Inconsistent API for non-printable characters * Probably more PyUserInput =========== A module for cross-platform control of the mouse and keyboard in python that is simple to use. Mouse control and capture should be fairly complete and mature on all supported platforms. Any incompatabilities should be reported. Basic keyboard handling should work, but known issues exist. Contributions welcome. For some less-common keyboard keys and layouts, you may want to look at [Pynput](https://github.com/moses-palmer/pynput) Installation ------------ ### Dependencies Depending on your platform, you will need the following python modules for PyUserInput to function: * Linux - Xlib (python-xlib) * Mac - Quartz, AppKit * Windows - pywin32, pyHook If you don't have the dependencies appropriate for your system, the installation of PyUserInput should warn you of that fact. ### Windows Dependencies PyUserInput on Windows depends on pywin32, a set of Windows extensions for Python. To install them, please visit http://sourceforge.net/projects/pywin32/files/pywin32/, choose the latest build, and download and run the file corresponding to your version and architecture of Python. ### Using pip PyUserInput is registered on PyPI (Python Package Index) and updated periodically, so tools such as pip or easy_install should work. `pip install PyUserInput` ### From Source You can download a [zip file from Github](https://github.com/PyUserInput/PyUserInput/archive/master.zip) or a tar.gz file from PyPI that contains the source code. Once you have uncompressed the file into a directory, you should navigate a terminal session to the directory that contains setup.py. The next step is to type the following command: `python setup.py install` If you are on linux and have a problem with permissions, you may need to prepend the command with sudo. For any other installation problems, open an issue on GitHub. How to get started ------------------ After installing PyUserInput, you should have pymouse and pykeyboard modules in your python path. Let's make a mouse and keyboard object: ```python from pymouse import PyMouse from pykeyboard import PyKeyboard m = PyMouse() k = PyKeyboard() ``` Here's an example of clicking the center of the screen and typing "Hello, World!": ```python x_dim, y_dim = m.screen_size() m.click(x_dim/2, y_dim/2, 1) k.type_string('Hello, World!') ``` PyKeyboard allows for a range of ways for sending keystrokes: ```python # pressing a key k.press_key('H') # which you then follow with a release of the key k.release_key('H') # or you can 'tap' a key which does both k.tap_key('e') # note that that tap_key does support a way of repeating keystrokes with a interval time between each k.tap_key('l',n=2,interval=5) # and you can send a string if needed too k.type_string('o World!') ``` and it supports a wide range of special keys: ```python #Create an Alt+Tab combo k.press_key(k.alt_key) k.tap_key(k.tab_key) k.release_key(k.alt_key) k.tap_key(k.function_keys[5]) # Tap F5 k.tap_key(k.numpad_keys['Home']) # Tap 'Home' on the numpad k.tap_key(k.numpad_keys[5], n=3) # Tap 5 on the numpad, thrice ``` Note you can also send multiple keystrokes together (e.g. when accessing a keyboard shortcut) using the press_keys method: ```python # Mac example k.press_keys(['Command','shift','3']) # Windows example k.press_keys([k.windows_l_key,'d']) ``` Consistency between platforms is a big challenge; Please look at the source for the operating system that you are using to help understand the format of the keys that you would need to send. For example: ```python # Windows k.tap_key(k.alt_key) # Mac k.tap_key('Alternate') ``` I'd like to make a special note about using PyMouseEvent and PyKeyboardEvent. These objects are a framework for listening for mouse and keyboard input; they don't do anything besides listen until you subclass them. I'm still formalizing PyKeyboardEvent, so here's an example of subclassing PyMouseEvent: ```python from pymouse import PyMouseEvent def fibo(): a = 0 yield a b = 1 yield b while True: a, b = b, a+b yield b class Clickonacci(PyMouseEvent): def __init__(self): PyMouseEvent.__init__(self) self.fibo = fibo() def click(self, x, y, button, press): '''Print Fibonacci numbers when the left click is pressed.''' if button == 1: if press: print(self.fibo.next()) else: # Exit if any other mouse button used self.stop() C = Clickonacci() C.run() ``` Intended Functionality of Capturing in PyUserInput -------------------------------------------------- For PyMouseEvent classes, the variables "capture" and "capture_move" may be passed during instantiation. If `capture=True` is passed, the intended result is that all mouse button input will go to your program and nowhere else. The same is true for `capture_move=True` except it deals with mouse pointer motion instead of the buttons. Both may be set simultaneously, and serve to prevent events from propagating further. If you notice any bugs with this behavior, please bring it to our attention. A Short Todo List ----------------- These are a few things I am considering for future development in PyUserInput: * Get rid of PyHook * Make PyKeyboard work for less-common keys and layouts * Make friends with more developers, help is needed... ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617681733.332567 PyUserInput-0.1.12/pykeyboard/0002755000174500001730000000000000000000000015732 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/__init__.py0000644000174500001730000000234200000000000020042 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . """ The goal of PyMouse is to have a cross-platform way to control the mouse. PyMouse should work on Windows, Mac and any Unix that has xlib. PyKeyboard is a part of PyUserInput, along with PyMouse, for more information about this project, see: http://github.com/SavinaRoja/PyUserInput """ import sys if sys.platform.startswith('java'): from .java_ import PyKeyboard elif sys.platform == 'darwin': from .mac import PyKeyboard, PyKeyboardEvent elif sys.platform == 'win32': from .windows import PyKeyboard, PyKeyboardEvent else: from .x11 import PyKeyboard, PyKeyboardEvent ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/base.py0000644000174500001730000001661600000000000017226 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . """ As the base file, this provides a rough operational model along with the framework to be extended by each platform. """ import time from threading import Thread class PyKeyboardMeta(object): """ The base class for PyKeyboard. Represents basic operational model. """ #: We add this named character for convenience space = ' ' def press_key(self, character=''): """Press a given character key.""" raise NotImplementedError def release_key(self, character=''): """Release a given character key.""" raise NotImplementedError def tap_key(self, character='', n=1, interval=0): """Press and release a given character key n times.""" for i in range(n): self.press_key(character) self.release_key(character) time.sleep(interval) def press_keys(self,characters=[]): """Press a given character key.""" for character in characters: self.press_key(character) for character in characters: self.release_key(character) def type_string(self, char_string, interval=0): """ A convenience method for typing longer strings of characters. Generates as few Shift events as possible.""" shift = False for char in char_string: if self.is_char_shifted(char): if not shift: # Only press Shift as needed time.sleep(interval) self.press_key(self.shift_key) shift = True #In order to avoid tap_key pressing Shift, we need to pass the #unshifted form of the character if char in '<>?:"{}|~!@#$%^&*()_+': ch_index = '<>?:"{}|~!@#$%^&*()_+'.index(char) unshifted_char = ",./;'[]\\`1234567890-="[ch_index] else: unshifted_char = char.lower() time.sleep(interval) self.tap_key(unshifted_char) else: # Unshifted already if shift and char != ' ': # Only release Shift as needed self.release_key(self.shift_key) shift = False time.sleep(interval) self.tap_key(char) if shift: # Turn off Shift if it's still ON self.release_key(self.shift_key) def special_key_assignment(self): """Makes special keys more accessible.""" raise NotImplementedError def lookup_character_value(self, character): """ If necessary, lookup a valid API value for the key press from the character. """ raise NotImplementedError def is_char_shifted(self, character): """Returns True if the key character is uppercase or shifted.""" if character.isupper(): return True if character in '<>?:"{}|~!@#$%^&*()_+': return True return False class PyKeyboardEventMeta(Thread): """ The base class for PyKeyboard. Represents basic operational model. """ #One of the most variable components of keyboards throughout history and #across manufacturers is the Modifier Key... #I am attempting to cover a lot of bases to make using PyKeyboardEvent #simpler, without digging a bunch of traps for incompatibilities between #platforms. #Keeping track of the keyboard's state is not only necessary at times to #correctly interpret character identities in keyboard events, but should #also enable a user to easily query modifier states without worrying about #chaining event triggers for mod-combinations #The keyboard's state will be represented by an integer, the individual #mod keys by a bit mask of that integer state = 0 #Each platform should assign, where applicable/possible, the bit masks for #modifier keys initially set to 0 here. Not all modifiers are recommended #for cross-platform use modifier_bits = {'Shift': 1, 'Lock': 2, 'Control': 4, 'Mod1': 8, # X11 dynamic assignment 'Mod2': 16, # X11 dynamic assignment 'Mod3': 32, # X11 dynamic assignment 'Mod4': 64, # X11 dynamic assignment 'Mod5': 128, # X11 dynamic assignment 'Alt': 0, 'AltGr': 0, # Uncommon 'Caps_Lock': 0, 'Command': 0, # Mac key without generic equivalent 'Function': 0, # Not advised; typically undetectable 'Hyper': 0, # Uncommon? 'Meta': 0, # Uncommon? 'Num_Lock': 0, 'Mode_switch': 0, # Uncommon 'Shift_Lock': 0, # Uncommon 'Super': 0, # X11 key, sometimes equivalent to Windows 'Windows': 0} # Windows key, sometimes equivalent to Super #Make the modifiers dictionary for individual states, setting all to off modifiers = {} for key in modifier_bits.keys(): modifiers[key] = False def __init__(self, capture=False): Thread.__init__(self) self.daemon = True self.capture = capture self.state = True self.configure_keys() def run(self): self.state = True def stop(self): self.state = False def handler(self): raise NotImplementedError def tap(self, keycode, character, press): """ Subclass this method with your key event handler. It will receive the keycode associated with the key event, as well as string name for the key if one can be assigned (keyboard mask states will apply). The argument 'press' will be True if the key was depressed and False if the key was released. """ pass def escape(self, event): """ A function that defines when to stop listening; subclass this with your escape behavior. If the program is meant to stop, this method should return True. Every key event will go through this method before going to tap(), allowing this method to check for exit conditions. The default behavior is to stop when the 'Esc' key is pressed. If one wishes to use key combinations, or key series, one might be interested in reading about Finite State Machines. http://en.wikipedia.org/wiki/Deterministic_finite_automaton """ condition = None return event == condition def configure_keys(self): """ Does per-platform work of configuring the modifier keys as well as data structures for simplified key access. Does nothing in this base implementation. """ pass ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/java_.py0000644000174500001730000000121600000000000017362 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/mac.py0000644000174500001730000002050600000000000017045 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . import time import Quartz from AppKit import NSSystemDefined, NSEvent from .base import PyKeyboardMeta, PyKeyboardEventMeta import logging logger = logging.getLogger(__name__) # Taken from events.h # /System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h character_translate_table = { 'a': 0x00, 's': 0x01, 'd': 0x02, 'f': 0x03, 'h': 0x04, 'g': 0x05, 'z': 0x06, 'x': 0x07, 'c': 0x08, 'v': 0x09, 'b': 0x0b, 'q': 0x0c, 'w': 0x0d, 'e': 0x0e, 'r': 0x0f, 'y': 0x10, 't': 0x11, '1': 0x12, '2': 0x13, '3': 0x14, '4': 0x15, '6': 0x16, '5': 0x17, '=': 0x18, '9': 0x19, '7': 0x1a, '-': 0x1b, '8': 0x1c, '0': 0x1d, ']': 0x1e, 'o': 0x1f, 'u': 0x20, '[': 0x21, 'i': 0x22, 'p': 0x23, 'l': 0x25, 'j': 0x26, '\'': 0x27, 'k': 0x28, ';': 0x29, '\\': 0x2a, ',': 0x2b, '/': 0x2c, 'n': 0x2d, 'm': 0x2e, '.': 0x2f, '`': 0x32, ' ': 0x31, '\r': 0x24, '\t': 0x30, '\n': 0x24, 'return' : 0x24, 'tab' : 0x30, 'space' : 0x31, 'delete' : 0x33, 'escape' : 0x35, 'command' : 0x37, 'shift' : 0x38, 'capslock' : 0x39, 'option' : 0x3A, 'alternate' : 0x3A, 'control' : 0x3B, 'rightshift' : 0x3C, 'rightoption' : 0x3D, 'rightcontrol' : 0x3E, 'function' : 0x3F, 'left' : 0x7B, 'right' : 0x7C, 'down' : 0x7D, 'up' : 0x7E, } #inverse of character_translate_table for key code to name lookups key_code_translate_table = dict((key_code, key_name) for key_name, key_code in character_translate_table.items()) # Taken from ev_keymap.h # http://www.opensource.apple.com/source/IOHIDFamily/IOHIDFamily-86.1/IOHIDSystem/IOKit/hidsystem/ev_keymap.h special_key_translate_table = { 'KEYTYPE_SOUND_UP': 0, 'KEYTYPE_SOUND_DOWN': 1, 'KEYTYPE_BRIGHTNESS_UP': 2, 'KEYTYPE_BRIGHTNESS_DOWN': 3, 'KEYTYPE_CAPS_LOCK': 4, 'KEYTYPE_HELP': 5, 'POWER_KEY': 6, 'KEYTYPE_MUTE': 7, 'UP_ARROW_KEY': 8, 'DOWN_ARROW_KEY': 9, 'KEYTYPE_NUM_LOCK': 10, 'KEYTYPE_CONTRAST_UP': 11, 'KEYTYPE_CONTRAST_DOWN': 12, 'KEYTYPE_LAUNCH_PANEL': 13, 'KEYTYPE_EJECT': 14, 'KEYTYPE_VIDMIRROR': 15, 'KEYTYPE_PLAY': 16, 'KEYTYPE_NEXT': 17, 'KEYTYPE_PREVIOUS': 18, 'KEYTYPE_FAST': 19, 'KEYTYPE_REWIND': 20, 'KEYTYPE_ILLUMINATION_UP': 21, 'KEYTYPE_ILLUMINATION_DOWN': 22, 'KEYTYPE_ILLUMINATION_TOGGLE': 23 } class PyKeyboard(PyKeyboardMeta): def __init__(self): self.shift_key = 'shift' self.modifier_table = {'Shift':False,'Command':False,'Control':False,'Alternate':False} def press_key(self, key): if key.title() in self.modifier_table: self.modifier_table.update({key.title():True}) if key in special_key_translate_table: self._press_special_key(key, True) else: self._press_normal_key(key, True) def release_key(self, key): # remove the key if key.title() in self.modifier_table: self.modifier_table.update({key.title():False}) if key in special_key_translate_table: self._press_special_key(key, False) else: self._press_normal_key(key, False) def special_key_assignment(self): self.volume_mute_key = 'KEYTYPE_MUTE' self.volume_down_key = 'KEYTYPE_SOUND_DOWN' self.volume_up_key = 'KEYTYPE_SOUND_UP' self.media_play_pause_key = 'KEYTYPE_PLAY' # Doesn't work :( # self.media_next_track_key = 'KEYTYPE_NEXT' # self.media_prev_track_key = 'KEYTYPE_PREVIOUS' def _press_normal_key(self, key, down): try: key_code = character_translate_table[key.lower()] # kCGEventFlagMaskAlternate | kCGEventFlagMaskCommand | kCGEventFlagMaskControl | kCGEventFlagMaskShift event = Quartz.CGEventCreateKeyboardEvent(None, key_code, down) mkeyStr = '' for mkey in self.modifier_table: if self.modifier_table[mkey]: if len(mkeyStr)>1: mkeyStr = mkeyStr+' ^ ' mkeyStr = mkeyStr+'Quartz.kCGEventFlagMask'+mkey if len(mkeyStr)>1: eval('Quartz.CGEventSetFlags(event, '+mkeyStr+')') Quartz.CGEventPost(Quartz.kCGHIDEventTap, event) if key.lower() == "shift": time.sleep(.1) except KeyError: raise RuntimeError("Key {} not implemented.".format(key)) def _press_special_key(self, key, down): """ Helper method for special keys. Source: http://stackoverflow.com/questions/11045814/emulate-media-key-press-on-mac """ key_code = special_key_translate_table[key] ev = NSEvent.otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2_( NSSystemDefined, # type (0,0), # location 0xa00 if down else 0xb00, # flags 0, # timestamp 0, # window 0, # ctx 8, # subtype (key_code << 16) | ((0xa if down else 0xb) << 8), # data1 -1 # data2 ) Quartz.CGEventPost(0, ev.CGEvent()) class PyKeyboardEvent(PyKeyboardEventMeta): def __init__(self,diagnostic=False): self.diagnostic = diagnostic PyKeyboardEventMeta.__init__(self) def run(self): tap = Quartz.CGEventTapCreate( Quartz.kCGSessionEventTap, Quartz.kCGHeadInsertEventTap, Quartz.kCGEventTapOptionDefault, Quartz.CGEventMaskBit(Quartz.kCGEventKeyDown) | Quartz.CGEventMaskBit(Quartz.kCGEventKeyUp), self.handler, None) loopsource = Quartz.CFMachPortCreateRunLoopSource(None, tap, 0) self.loop = Quartz.CFRunLoopGetCurrent() Quartz.CFRunLoopAddSource(self.loop, loopsource, Quartz.kCFRunLoopDefaultMode) Quartz.CGEventTapEnable(tap, True) while self.state: Quartz.CFRunLoopRunInMode(Quartz.kCFRunLoopDefaultMode, 5, False) def escape(self, key): return key_code_translate_table[key] == 'escape' def stop(self): """Stop listening for keyboard input events.""" Quartz.CFRunLoopStop(self.loop) self.state = False def _diagnostic(self,key,event): logger.info('\n---Keyboard Event Diagnostic---') logger.debug('MessageName:', event.MessageName) logger.debug('Message:', event.Message) logger.debug('Time:', event.Time) logger.debug('Window:', event.Window) logger.debug('WindowName:', event.WindowName) logger.debug('Ascii:', event.Ascii, ',', chr(event.Ascii)) logger.info('Key:',key_code_translate_table[key]) logger.info('Key Code:',key) logger.debug('KeyID:', event.KeyID) logger.debug('ScanCode:', event.ScanCode) logger.debug('Extended:', event.Extended) logger.debug('Injected:', event.Injected) logger.debug('Alt', event.Alt) logger.debug('Transition', event.Transition) logger.info('---') def handler(self, proxy, type, event, refcon): key = Quartz.CGEventGetIntegerValueField(event, Quartz.kCGKeyboardEventKeycode) if self.escape(key): # A chance to escape self.stop() if self.diagnostic: self._diagnostic(key,event) if type == Quartz.kCGEventKeyDown: self.key_press(key) elif type == Quartz.kCGEventKeyUp: self.key_release(key) if self.capture: Quartz.CGEventSetType(event, Quartz.kCGEventNull) return event ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/mir.py0000644000174500001730000000121600000000000017071 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/wayland.py0000644000174500001730000000121600000000000017741 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/windows.py0000644000174500001730000002735400000000000020007 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . from ctypes import * import win32api from win32con import * import pythoncom from .base import PyKeyboardMeta, PyKeyboardEventMeta import time import logging logger = logging.getLogger(__name__) class SupportError(Exception): """For keys not supported on this system""" def __init__(self, value): self.value = value def __str__(self): return('The {0} key is not supported in Windows'.format(self.value)) class PyKeyboard(PyKeyboardMeta): """ The PyKeyboard implementation for Windows systems. This allows one to simulate keyboard input. """ def __init__(self): PyKeyboardMeta.__init__(self) self.special_key_assignment() def press_key(self, character=''): """ Press a given character key. """ try: shifted = self.is_char_shifted(character) except AttributeError: win32api.keybd_event(character, 0, 0, 0) else: if shifted: win32api.keybd_event(self.shift_key, 0, 0, 0) char_vk = win32api.VkKeyScan(character) win32api.keybd_event(char_vk, 0, 0, 0) def release_key(self, character=''): """ Release a given character key. """ try: shifted = self.is_char_shifted(character) except AttributeError: win32api.keybd_event(character, 0, KEYEVENTF_KEYUP, 0) else: if shifted: win32api.keybd_event(self.shift_key, 0, KEYEVENTF_KEYUP, 0) char_vk = win32api.VkKeyScan(character) win32api.keybd_event(char_vk, 0, KEYEVENTF_KEYUP, 0) def special_key_assignment(self): """ Special Key assignment for windows """ #As defined by Microsoft, refer to: #http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx self.backspace_key = VK_BACK self.tab_key = VK_TAB self.clear_key = VK_CLEAR self.return_key = VK_RETURN self.enter_key = self.return_key # Because many keyboards call it "Enter" self.shift_key = VK_SHIFT self.shift_l_key = VK_LSHIFT self.shift_r_key = VK_RSHIFT self.control_key = VK_CONTROL self.control_l_key = VK_LCONTROL self.control_r_key = VK_RCONTROL #Windows uses "menu" to refer to Alt... self.menu_key = VK_MENU self.alt_l_key = VK_LMENU self.alt_r_key = VK_RMENU self.altgr_key = VK_RMENU self.alt_key = self.alt_l_key self.pause_key = VK_PAUSE self.caps_lock_key = VK_CAPITAL self.capital_key = self.caps_lock_key self.num_lock_key = VK_NUMLOCK self.scroll_lock_key = VK_SCROLL #Windows Language Keys, self.kana_key = VK_KANA self.hangeul_key = VK_HANGEUL # old name - should be here for compatibility self.hangul_key = VK_HANGUL self.junjua_key = VK_JUNJA self.final_key = VK_FINAL self.hanja_key = VK_HANJA self.kanji_key = VK_KANJI self.convert_key = VK_CONVERT self.nonconvert_key = VK_NONCONVERT self.accept_key = VK_ACCEPT self.modechange_key = VK_MODECHANGE #More Keys self.escape_key = VK_ESCAPE self.space_key = VK_SPACE self.prior_key = VK_PRIOR self.next_key = VK_NEXT self.page_up_key = self.prior_key self.page_down_key = self.next_key self.home_key = VK_HOME self.up_key = VK_UP self.down_key = VK_DOWN self.left_key = VK_LEFT self.right_key = VK_RIGHT self.end_key = VK_END self.select_key = VK_SELECT self.print_key = VK_PRINT self.snapshot_key = VK_SNAPSHOT self.print_screen_key = self.snapshot_key self.execute_key = VK_EXECUTE self.insert_key = VK_INSERT self.delete_key = VK_DELETE self.help_key = VK_HELP self.windows_l_key = VK_LWIN self.super_l_key = self.windows_l_key self.windows_r_key = VK_RWIN self.super_r_key = self.windows_r_key self.apps_key = VK_APPS #Numpad self.keypad_keys = {'Space': None, 'Tab': None, 'Enter': None, # Needs Fixing 'F1': None, 'F2': None, 'F3': None, 'F4': None, 'Home': VK_NUMPAD7, 'Left': VK_NUMPAD4, 'Up': VK_NUMPAD8, 'Right': VK_NUMPAD6, 'Down': VK_NUMPAD2, 'Prior': None, 'Page_Up': VK_NUMPAD9, 'Next': None, 'Page_Down': VK_NUMPAD3, 'End': VK_NUMPAD1, 'Begin': None, 'Insert': VK_NUMPAD0, 'Delete': VK_DECIMAL, 'Equal': None, # Needs Fixing 'Multiply': VK_MULTIPLY, 'Add': VK_ADD, 'Separator': VK_SEPARATOR, 'Subtract': VK_SUBTRACT, 'Decimal': VK_DECIMAL, 'Divide': VK_DIVIDE, 0: VK_NUMPAD0, 1: VK_NUMPAD1, 2: VK_NUMPAD2, 3: VK_NUMPAD3, 4: VK_NUMPAD4, 5: VK_NUMPAD5, 6: VK_NUMPAD6, 7: VK_NUMPAD7, 8: VK_NUMPAD8, 9: VK_NUMPAD9} self.numpad_keys = self.keypad_keys #FKeys self.function_keys = [None, VK_F1, VK_F2, VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10, VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16, VK_F17, VK_F18, VK_F19, VK_F20, VK_F21, VK_F22, VK_F23, VK_F24, None, None, None, None, None, None, None, None, None, None, None] # Up to 36 as in x11 #Miscellaneous self.cancel_key = VK_CANCEL self.break_key = self.cancel_key self.mode_switch_key = VK_MODECHANGE self.browser_back_key = VK_BROWSER_BACK self.browser_forward_key = VK_BROWSER_FORWARD self.processkey_key = VK_PROCESSKEY self.attn_key = VK_ATTN self.crsel_key = VK_CRSEL self.exsel_key = VK_EXSEL self.ereof_key = VK_EREOF self.play_key = VK_PLAY self.zoom_key = VK_ZOOM self.noname_key = VK_NONAME self.pa1_key = VK_PA1 self.oem_clear_key = VK_OEM_CLEAR self.volume_mute_key = VK_VOLUME_MUTE self.volume_down_key = VK_VOLUME_DOWN self.volume_up_key = VK_VOLUME_UP self.media_next_track_key = VK_MEDIA_NEXT_TRACK self.media_prev_track_key = VK_MEDIA_PREV_TRACK self.media_play_pause_key = VK_MEDIA_PLAY_PAUSE self.begin_key = self.home_key #LKeys - Unsupported self.l_keys = [None] * 11 #RKeys - Unsupported self.r_keys = [None] * 16 #Other unsupported Keys from X11 self.linefeed_key = None self.find_key = None self.meta_l_key = None self.meta_r_key = None self.sys_req_key = None self.hyper_l_key = None self.hyper_r_key = None self.undo_key = None self.redo_key = None self.script_switch_key = None class PyKeyboardEvent(PyKeyboardEventMeta): """ The PyKeyboardEvent implementation for Windows Systems. This allows one to listen for keyboard input. """ def __init__(self, diagnostic=False): self.diagnostic = diagnostic import pyHook PyKeyboardEventMeta.__init__(self) self.hm = pyHook.HookManager() self.hc = pyHook.HookConstants() self.lock_meaning = None def run(self): """Begin listening for keyboard input events.""" self.state = True self.hm.KeyAll = self.handler self.hm.HookKeyboard() while self.state: time.sleep(0.01) pythoncom.PumpWaitingMessages() def stop(self): """Stop listening for keyboard input events.""" self.hm.UnhookKeyboard() self.state = False def handler(self, event): """Upper level handler of keyboard events.""" if self.escape(event): # A chance to escape self.stop() elif self.diagnostic: self._diagnostic(event) else: self._tap(event) #This is needed according to the pyHook tutorials 'http://sourceforge.net/apps/mediawiki/pyhook/index.php?title=PyHook_Tutorial' return True def _tap(self, event): keycode = event.KeyID press_bool = (event.Message in [self.hc.WM_KEYDOWN, self.hc.WM_SYSKEYDOWN]) #Not using event.GeyKey() because we want to differentiate between #KeyID and Ascii attributes of the event if event.Ascii != 0: character = chr(event.Ascii) else: character = self.hc.id_to_vk[keycode][3:] #TODO: Need to universalize keys between platforms. ie. 'Menu' -> 'Alt' self.tap(keycode, character, press_bool) def _diagnostic(self, event): """ This method is employed instead of _tap() if the PyKeyboardEvent is initialized with diagnostic=True. This makes some basic testing quickly and easily available. It will print out information regarding the event instead of passing information along to self.tap() """ logger.info('\n---Keyboard Event Diagnostic---') logger.info('MessageName:', event.MessageName) logger.info('Message:', event.Message) logger.info('Time:', event.Time) logger.info('Window:', event.Window) logger.info('WindowName:', event.WindowName) logger.info('Ascii:', event.Ascii, ',', chr(event.Ascii)) logger.info('Key:', event.Key) logger.info('KeyID:', event.KeyID) logger.info('ScanCode:', event.ScanCode) logger.info('Extended:', event.Extended) logger.info('Injected:', event.Injected) logger.info('Alt', event.Alt) logger.info('Transition', event.Transition) logger.info('---') def escape(self, event): return event.KeyID == VK_ESCAPE def toggle_shift_state(self): # This will be removed later '''Does toggling for the shift state.''' states = [1, 0] self.shift_state = states[self.shift_state] def toggle_alt_state(self): # This will be removed later '''Does toggling for the alt state.''' states = [2, None, 0] self.alt_state = states[self.alt_state] def configure_keys(self): """ This does initial configuration for keyboard modifier state tracking including alias setting and keycode list construction. """ pass ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/x11.py0000644000174500001730000005336400000000000016726 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . from Xlib.display import Display from Xlib import X from Xlib.ext.xtest import fake_input from Xlib.ext import record from Xlib.protocol import rq import Xlib.XK import Xlib.keysymdef.xkb from .base import PyKeyboardMeta, PyKeyboardEventMeta import logging logger = logging.getLogger(__name__) import time import string from pymouse.x11 import display_manager from .x11_keysyms import KEYSYMS class PyKeyboard(PyKeyboardMeta): """ The PyKeyboard implementation for X11 systems (mostly linux). This allows one to simulate keyboard input. """ def __init__(self, display=None): PyKeyboardMeta.__init__(self) self.display = Display(display) self.display2 = Display(display) self.special_key_assignment() def _handle_key(self, character, event): """Handles either a key press or release, depending on ``event``. :param character: The key to handle. See :meth:`press_key` and :meth:`release_key` for information about this parameter. :param event: The *Xlib* event. This should be either :attr:`Xlib.X.KeyPress` or :attr:`Xlib.X.KeyRelease` """ try: # Detect uppercase or shifted character shifted = self.is_char_shifted(character) except AttributeError: # Handle the case of integer keycode argument with display_manager(self.display) as d: fake_input(d, event, character) else: with display_manager(self.display) as d: if shifted: fake_input(d, event, self.shift_key) keycode = self.lookup_character_keycode(character) fake_input(d, event, keycode) def press_key(self, character=''): """ Press a given character key. Also works with character keycodes as integers, but not keysyms. """ self._handle_key(character, X.KeyPress) def release_key(self, character=''): """ Release a given character key. Also works with character keycodes as integers, but not keysyms. """ self._handle_key(character, X.KeyRelease) def special_key_assignment(self): """ Determines the keycodes for common special keys on the keyboard. These are integer values and can be passed to the other key methods. Generally speaking, these are non-printable codes. """ #This set of keys compiled using the X11 keysymdef.h file as reference #They comprise a relatively universal set of keys, though there may be #exceptions which may come up for other OSes and vendors. Countless #special cases exist which are not handled here, but may be extended. #TTY Function Keys self.backspace_key = self.lookup_character_keycode('BackSpace') self.tab_key = self.lookup_character_keycode('Tab') self.linefeed_key = self.lookup_character_keycode('Linefeed') self.clear_key = self.lookup_character_keycode('Clear') self.return_key = self.lookup_character_keycode('Return') self.enter_key = self.return_key # Because many keyboards call it "Enter" self.pause_key = self.lookup_character_keycode('Pause') self.scroll_lock_key = self.lookup_character_keycode('Scroll_Lock') self.sys_req_key = self.lookup_character_keycode('Sys_Req') self.escape_key = self.lookup_character_keycode('Escape') self.delete_key = self.lookup_character_keycode('Delete') #Modifier Keys self.shift_l_key = self.lookup_character_keycode('Shift_L') self.shift_r_key = self.lookup_character_keycode('Shift_R') self.shift_key = self.shift_l_key # Default Shift is left Shift self.alt_l_key = self.lookup_character_keycode('Alt_L') self.alt_r_key = self.lookup_character_keycode('Alt_R') self.altgr_key = self.lookup_character_keycode('ISO_Level3_Shift') self.alt_key = self.alt_l_key # Default Alt is left Alt self.control_l_key = self.lookup_character_keycode('Control_L') self.control_r_key = self.lookup_character_keycode('Control_R') self.control_key = self.control_l_key # Default Ctrl is left Ctrl self.caps_lock_key = self.lookup_character_keycode('Caps_Lock') self.capital_key = self.caps_lock_key # Some may know it as Capital self.shift_lock_key = self.lookup_character_keycode('Shift_Lock') self.meta_l_key = self.lookup_character_keycode('Meta_L') self.meta_r_key = self.lookup_character_keycode('Meta_R') self.super_l_key = self.lookup_character_keycode('Super_L') self.windows_l_key = self.super_l_key # Cross-support; also it's printed there self.super_r_key = self.lookup_character_keycode('Super_R') self.windows_r_key = self.super_r_key # Cross-support; also it's printed there self.hyper_l_key = self.lookup_character_keycode('Hyper_L') self.hyper_r_key = self.lookup_character_keycode('Hyper_R') #Cursor Control and Motion self.home_key = self.lookup_character_keycode('Home') self.up_key = self.lookup_character_keycode('Up') self.down_key = self.lookup_character_keycode('Down') self.left_key = self.lookup_character_keycode('Left') self.right_key = self.lookup_character_keycode('Right') self.end_key = self.lookup_character_keycode('End') self.begin_key = self.lookup_character_keycode('Begin') self.page_up_key = self.lookup_character_keycode('Page_Up') self.page_down_key = self.lookup_character_keycode('Page_Down') self.prior_key = self.lookup_character_keycode('Prior') self.next_key = self.lookup_character_keycode('Next') #Misc Functions self.select_key = self.lookup_character_keycode('Select') self.print_key = self.lookup_character_keycode('Print') self.print_screen_key = self.print_key # Seems to be the same thing self.snapshot_key = self.print_key # Another name for printscreen self.execute_key = self.lookup_character_keycode('Execute') self.insert_key = self.lookup_character_keycode('Insert') self.undo_key = self.lookup_character_keycode('Undo') self.redo_key = self.lookup_character_keycode('Redo') self.menu_key = self.lookup_character_keycode('Menu') self.apps_key = self.menu_key # Windows... self.find_key = self.lookup_character_keycode('Find') self.cancel_key = self.lookup_character_keycode('Cancel') self.help_key = self.lookup_character_keycode('Help') self.break_key = self.lookup_character_keycode('Break') self.mode_switch_key = self.lookup_character_keycode('Mode_switch') self.script_switch_key = self.lookup_character_keycode('script_switch') self.num_lock_key = self.lookup_character_keycode('Num_Lock') #Keypad Keys: Dictionary structure keypad = ['Space', 'Tab', 'Enter', 'F1', 'F2', 'F3', 'F4', 'Home', 'Left', 'Up', 'Right', 'Down', 'Prior', 'Page_Up', 'Next', 'Page_Down', 'End', 'Begin', 'Insert', 'Delete', 'Equal', 'Multiply', 'Add', 'Separator', 'Subtract', 'Decimal', 'Divide', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] self.keypad_keys = dict((k, self.lookup_character_keycode('KP_'+str(k))) for k in keypad) self.numpad_keys = self.keypad_keys #Function Keys/ Auxilliary Keys #FKeys self.function_keys = [None] + [self.lookup_character_keycode('F'+str(i)) for i in range(1,36)] #LKeys self.l_keys = [None] + [self.lookup_character_keycode('L'+str(i)) for i in range(1,11)] #RKeys self.r_keys = [None] + [self.lookup_character_keycode('R'+str(i)) for i in range(1,16)] #Unsupported keys from windows self.kana_key = None self.hangeul_key = None # old name - should be here for compatibility self.hangul_key = None self.junjua_key = None self.final_key = None self.hanja_key = None self.kanji_key = None self.convert_key = None self.nonconvert_key = None self.accept_key = None self.modechange_key = None self.sleep_key = None def lookup_character_keycode(self, character): """ Looks up the keysym for the character then returns the keycode mapping for that keysym. """ keysym = Xlib.XK.string_to_keysym(character) if not keysym: try: keysym = getattr(Xlib.keysymdef.xkb, 'XK_' + character, 0) except: keysym = 0 if not keysym: keysym = Xlib.XK.string_to_keysym(KEYSYMS[character]) return self.display.keysym_to_keycode(keysym) class PyKeyboardEvent(PyKeyboardEventMeta): """ The PyKeyboardEvent implementation for X11 systems (mostly linux). This allows one to listen for keyboard input. """ def __init__(self, capture=False, display=None): self.display = Display(display) self.display2 = Display(display) self.ctx = self.display2.record_create_context( 0, [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': (X.KeyPress, X.KeyRelease), 'errors': (0, 0), 'client_started': False, 'client_died': False, }]) self.lock_meaning = None #Get these dictionaries for converting keysyms and strings self.keysym_to_string, self.string_to_keysym = self.get_translation_dicts() #Identify and register special groups of keys self.modifier_keycodes = {} self.all_mod_keycodes = [] self.keypad_keycodes = [] #self.configure_keys() #Direct access to the display's keycode-to-keysym array logger.debug('Keycode to Keysym map') for i in range(len(self.display._keymap_codes)): logger.debug('{0}: {1}'.format(i, self.display._keymap_codes[i])) PyKeyboardEventMeta.__init__(self, capture) def run(self): """Begin listening for keyboard input events.""" self.state = True if self.capture: self.display2.screen().root.grab_keyboard(X.KeyPressMask | X.KeyReleaseMask, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime) self.display2.record_enable_context(self.ctx, self.handler) self.display2.record_free_context(self.ctx) def stop(self): """Stop listening for keyboard input events.""" self.state = False with display_manager(self.display) as d: d.record_disable_context(self.ctx) d.ungrab_keyboard(X.CurrentTime) with display_manager(self.display2): d.record_disable_context(self.ctx) d.ungrab_keyboard(X.CurrentTime) def handler(self, reply): """Upper level handler of keyboard events.""" data = reply.data while len(data): event, data = rq.EventField(None).parse_binary_value(data, self.display.display, None, None) if self.escape(event): # Quit if this returns True self.stop() else: self._tap(event) def _tap(self, event): keycode = event.detail press_bool = (event.type == X.KeyPress) #Detect modifier states from event.state for mod, bit in self.modifier_bits.items(): self.modifiers[mod] = event.state & bit if keycode in self.all_mod_keycodes: keysym = self.display.keycode_to_keysym(keycode, 0) character = self.keysym_to_string[keysym] else: character = self.lookup_char_from_keycode(keycode) #All key events get passed to self.tap() self.tap(keycode, character, press=press_bool) def lookup_char_from_keycode(self, keycode): """ This will conduct a lookup of the character or string associated with a given keycode. """ #TODO: Logic should be strictly adapted from X11's src/KeyBind.c #Right now the logic is based off of #http://tronche.com/gui/x/xlib/input/keyboard-encoding.html #Which I suspect is not the whole story and may likely cause bugs keysym_index = 0 #TODO: Display's Keysyms per keycode count? Do I need this? #If the Num_Lock is on, and the keycode corresponds to the keypad if self.modifiers['Num_Lock'] and keycode in self.keypad_keycodes: if self.modifiers['Shift'] or self.modifiers['Shift_Lock']: keysym_index = 0 else: keysym_index = 1 elif not self.modifiers['Shift'] and self.modifiers['Caps_Lock']: #Use the first keysym if uppercase or uncased #Use the uppercase keysym if the first is lowercase (second) keysym_index = 0 keysym = self.display.keycode_to_keysym(keycode, keysym_index) #TODO: Support Unicode, Greek, and special latin characters if keysym & 0x7f == keysym and chr(keysym) in 'abcdefghijklmnopqrstuvwxyz': keysym_index = 1 elif self.modifiers['Shift'] and self.modifiers['Caps_Lock']: keysym_index = 1 keysym = self.display.keycode_to_keysym(keycode, keysym_index) #TODO: Support Unicode, Greek, and special latin characters if keysym & 0x7f == keysym and chr(keysym) in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ': keysym_index = 0 elif self.modifiers['Shift'] or self.modifiers['Shift_Lock']: keysym_index = 1 if self.modifiers['Mode_switch']: keysym_index += 2 #Finally! Get the keysym keysym = self.display.keycode_to_keysym(keycode, keysym_index) #If the character is ascii printable, return that character if keysym & 0x7f == keysym and self.ascii_printable(keysym): return chr(keysym) #If the character was not printable, look for its name try: char = self.keysym_to_string[keysym] except KeyError: logger.info('Unable to determine character.') logger.info('Keycode: {0} KeySym {1}'.format(keycode, keysym)) return None else: return char def escape(self, event): if event.detail == self.lookup_character_keycode('Escape'): return True return False def configure_keys(self): """ This function locates the keycodes corresponding to special groups of keys and creates data structures of them for use by the PyKeyboardEvent instance; including the keypad keys and the modifiers. The keycodes pertaining to the keyboard modifiers are assigned by the modifier name in a dictionary. This dictionary can be accessed in the following manner: self.modifier_keycodes['Shift'] # All keycodes for Shift Masking It also assigns certain named modifiers (Alt, Num_Lock, Super), which may be dynamically assigned to Mod1 - Mod5 on different platforms. This should generally allow the user to do the following lookups on any system: self.modifier_keycodes['Alt'] # All keycodes for Alt Masking self.modifiers['Alt'] # State of Alt mask, non-zero if "ON" """ modifier_mapping = self.display.get_modifier_mapping() all_mod_keycodes = [] mod_keycodes = {} mod_index = [('Shift', X.ShiftMapIndex), ('Lock', X.LockMapIndex), ('Control', X.ControlMapIndex), ('Mod1', X.Mod1MapIndex), ('Mod2', X.Mod2MapIndex), ('Mod3', X.Mod3MapIndex), ('Mod4', X.Mod4MapIndex), ('Mod5', X.Mod5MapIndex)] #This gets the list of all keycodes per Modifier, assigns to name for name, index in mod_index: codes = [v for v in list(modifier_mapping[index]) if v] mod_keycodes[name] = codes all_mod_keycodes += codes def lookup_keycode(string): keysym = self.string_to_keysym[string] return self.display.keysym_to_keycode(keysym) #Dynamically assign Lock to Caps_Lock, Shift_Lock, Alt, Num_Lock, Super, #and mode switch. Set in both mod_keycodes and self.modifier_bits #Try to assign Lock to Caps_Lock or Shift_Lock shift_lock_keycode = lookup_keycode('Shift_Lock') caps_lock_keycode = lookup_keycode('Caps_Lock') if shift_lock_keycode in mod_keycodes['Lock']: mod_keycodes['Shift_Lock'] = [shift_lock_keycode] self.modifier_bits['Shift_Lock'] = self.modifier_bits['Lock'] self.lock_meaning = 'Shift_Lock' elif caps_lock_keycode in mod_keycodes['Lock']: mod_keycodes['Caps_Lock'] = [caps_lock_keycode] self.modifier_bits['Caps_Lock'] = self.modifier_bits['Lock'] self.lock_meaning = 'Caps_Lock' else: self.lock_meaning = None logger.debug('Lock is bound to {0}'.format(self.lock_meaning)) #Need to find out which Mod# to use for Alt, Num_Lock, Super, and #Mode_switch num_lock_keycodes = [lookup_keycode('Num_Lock')] alt_keycodes = [lookup_keycode(i) for i in ['Alt_L', 'Alt_R']] super_keycodes = [lookup_keycode(i) for i in ['Super_L', 'Super_R']] mode_switch_keycodes = [lookup_keycode('Mode_switch')] #Detect Mod number for Alt, Num_Lock, and Super for name, keycodes in list(mod_keycodes.items()): for alt_key in alt_keycodes: if alt_key in keycodes: mod_keycodes['Alt'] = keycodes self.modifier_bits['Alt'] = self.modifier_bits[name] for num_lock_key in num_lock_keycodes: if num_lock_key in keycodes: mod_keycodes['Num_Lock'] = keycodes self.modifier_bits['Num_Lock'] = self.modifier_bits[name] for super_key in super_keycodes: if super_key in keycodes: mod_keycodes['Super'] = keycodes self.modifier_bits['Super'] = self.modifier_bits[name] for mode_switch_key in mode_switch_keycodes: if mode_switch_key in keycodes: mod_keycodes['Mode_switch'] = keycodes self.modifier_bits['Mode_switch'] = self.modifier_bits[name] #Assign the mod_keycodes to a local variable for access self.modifier_keycodes = mod_keycodes self.all_mod_keycodes = all_mod_keycodes #TODO: Determine if this might fail, perhaps iterate through the mapping #and identify all keycodes with registered keypad keysyms? #Acquire the full list of keypad keycodes self.keypad_keycodes = [] keypad = ['Space', 'Tab', 'Enter', 'F1', 'F2', 'F3', 'F4', 'Home', 'Left', 'Up', 'Right', 'Down', 'Prior', 'Page_Up', 'Next', 'Page_Down', 'End', 'Begin', 'Insert', 'Delete', 'Equal', 'Multiply', 'Add', 'Separator', 'Subtract', 'Decimal', 'Divide', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] for keyname in keypad: keypad_keycode = self.lookup_character_keycode('KP_' + keyname) self.keypad_keycodes.append(keypad_keycode) def lookup_character_keycode(self, character): """ Looks up the keysym for the character then returns the keycode mapping for that keysym. """ keysym = self.string_to_keysym.get(character, 0) if keysym == 0: keysym = self.string_to_keysym.get(KEYSYMS[character], 0) return self.display.keysym_to_keycode(keysym) def get_translation_dicts(self): """ Returns dictionaries for the translation of keysyms to strings and from strings to keysyms. """ keysym_to_string_dict = {} string_to_keysym_dict = {} #XK loads latin1 and miscellany on its own; load latin2-4 and greek Xlib.XK.load_keysym_group('latin2') Xlib.XK.load_keysym_group('latin3') Xlib.XK.load_keysym_group('latin4') Xlib.XK.load_keysym_group('greek') #Make a standard dict and the inverted dict for string, keysym in Xlib.XK.__dict__.items(): if string.startswith('XK_'): string_to_keysym_dict[string[3:]] = keysym keysym_to_string_dict[keysym] = string[3:] return keysym_to_string_dict, string_to_keysym_dict def ascii_printable(self, keysym): """ If the keysym corresponds to a non-printable ascii character this will return False. If it is printable, then True will be returned. ascii 11 (vertical tab) and ascii 12 are printable, chr(11) and chr(12) will return '\x0b' and '\x0c' respectively. """ if 0 <= keysym < 9: return False elif 13 < keysym < 32: return False elif keysym > 126: return False else: return True ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pykeyboard/x11_keysyms.py0000644000174500001730000005755200000000000020515 0ustar00janitorsbuild# coding: utf-8 # Copyright 2015 Moses Palmér # # This program is free software: you can redistribute it and/or modify it # under the terms of the GNU 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 General Public License for more # details. # # You should have received a copy of the GNU General Public License along with # this program. If not, see . KEYSYMS = { u'\u0020': 'space', u'\u0021': 'exclam', u'\u0022': 'quotedbl', u'\u0023': 'numbersign', u'\u0024': 'dollar', u'\u0025': 'percent', u'\u0026': 'ampersand', u'\u0027': 'apostrophe', u'\u0027': 'quoteright', u'\u0028': 'parenleft', u'\u0029': 'parenright', u'\u002a': 'asterisk', u'\u002b': 'plus', u'\u002c': 'comma', u'\u002d': 'minus', u'\u002e': 'period', u'\u002f': 'slash', u'\u0030': '0', u'\u0031': '1', u'\u0032': '2', u'\u0033': '3', u'\u0034': '4', u'\u0035': '5', u'\u0036': '6', u'\u0037': '7', u'\u0038': '8', u'\u0039': '9', u'\u003a': 'colon', u'\u003b': 'semicolon', u'\u003c': 'less', u'\u003d': 'equal', u'\u003e': 'greater', u'\u003f': 'question', u'\u0040': 'at', u'\u0041': 'A', u'\u0042': 'B', u'\u0043': 'C', u'\u0044': 'D', u'\u0045': 'E', u'\u0046': 'F', u'\u0047': 'G', u'\u0048': 'H', u'\u0049': 'I', u'\u004a': 'J', u'\u004b': 'K', u'\u004c': 'L', u'\u004d': 'M', u'\u004e': 'N', u'\u004f': 'O', u'\u0050': 'P', u'\u0051': 'Q', u'\u0052': 'R', u'\u0053': 'S', u'\u0054': 'T', u'\u0055': 'U', u'\u0056': 'V', u'\u0057': 'W', u'\u0058': 'X', u'\u0059': 'Y', u'\u005a': 'Z', u'\u005b': 'bracketleft', u'\u005c': 'backslash', u'\u005d': 'bracketright', u'\u005e': 'asciicircum', u'\u005f': 'underscore', u'\u0060': 'grave', u'\u0060': 'quoteleft', u'\u0061': 'a', u'\u0062': 'b', u'\u0063': 'c', u'\u0064': 'd', u'\u0065': 'e', u'\u0066': 'f', u'\u0067': 'g', u'\u0068': 'h', u'\u0069': 'i', u'\u006a': 'j', u'\u006b': 'k', u'\u006c': 'l', u'\u006d': 'm', u'\u006e': 'n', u'\u006f': 'o', u'\u0070': 'p', u'\u0071': 'q', u'\u0072': 'r', u'\u0073': 's', u'\u0074': 't', u'\u0075': 'u', u'\u0076': 'v', u'\u0077': 'w', u'\u0078': 'x', u'\u0079': 'y', u'\u007a': 'z', u'\u007b': 'braceleft', u'\u007c': 'bar', u'\u007d': 'braceright', u'\u007e': 'asciitilde', u'\u00a0': 'nobreakspace', u'\u00a1': 'exclamdown', u'\u00a2': 'cent', u'\u00a3': 'sterling', u'\u00a4': 'currency', u'\u00a5': 'yen', u'\u00a6': 'brokenbar', u'\u00a7': 'section', u'\u00a8': 'diaeresis', u'\u00a9': 'copyright', u'\u00aa': 'ordfeminine', u'\u00ab': 'guillemotleft', u'\u00ac': 'notsign', u'\u00ad': 'hyphen', u'\u00ae': 'registered', u'\u00af': 'macron', u'\u00b0': 'degree', u'\u00b1': 'plusminus', u'\u00b2': 'twosuperior', u'\u00b3': 'threesuperior', u'\u00b4': 'acute', u'\u00b5': 'mu', u'\u00b6': 'paragraph', u'\u00b7': 'periodcentered', u'\u00b8': 'cedilla', u'\u00b9': 'onesuperior', u'\u00ba': 'masculine', u'\u00bb': 'guillemotright', u'\u00bc': 'onequarter', u'\u00bd': 'onehalf', u'\u00be': 'threequarters', u'\u00bf': 'questiondown', u'\u00c0': 'Agrave', u'\u00c1': 'Aacute', u'\u00c2': 'Acircumflex', u'\u00c3': 'Atilde', u'\u00c4': 'Adiaeresis', u'\u00c5': 'Aring', u'\u00c6': 'AE', u'\u00c7': 'Ccedilla', u'\u00c8': 'Egrave', u'\u00c9': 'Eacute', u'\u00ca': 'Ecircumflex', u'\u00cb': 'Ediaeresis', u'\u00cc': 'Igrave', u'\u00cd': 'Iacute', u'\u00ce': 'Icircumflex', u'\u00cf': 'Idiaeresis', u'\u00d0': 'ETH', u'\u00d0': 'Eth', u'\u00d1': 'Ntilde', u'\u00d2': 'Ograve', u'\u00d3': 'Oacute', u'\u00d4': 'Ocircumflex', u'\u00d5': 'Otilde', u'\u00d6': 'Odiaeresis', u'\u00d7': 'multiply', u'\u00d8': 'Ooblique', u'\u00d9': 'Ugrave', u'\u00da': 'Uacute', u'\u00db': 'Ucircumflex', u'\u00dc': 'Udiaeresis', u'\u00dd': 'Yacute', u'\u00de': 'THORN', u'\u00de': 'Thorn', u'\u00df': 'ssharp', u'\u00e0': 'agrave', u'\u00e1': 'aacute', u'\u00e2': 'acircumflex', u'\u00e3': 'atilde', u'\u00e4': 'adiaeresis', u'\u00e5': 'aring', u'\u00e6': 'ae', u'\u00e7': 'ccedilla', u'\u00e8': 'egrave', u'\u00e9': 'eacute', u'\u00ea': 'ecircumflex', u'\u00eb': 'ediaeresis', u'\u00ec': 'igrave', u'\u00ed': 'iacute', u'\u00ee': 'icircumflex', u'\u00ef': 'idiaeresis', u'\u00f0': 'eth', u'\u00f1': 'ntilde', u'\u00f2': 'ograve', u'\u00f3': 'oacute', u'\u00f4': 'ocircumflex', u'\u00f5': 'otilde', u'\u00f6': 'odiaeresis', u'\u00f7': 'division', u'\u00f8': 'oslash', u'\u00f9': 'ugrave', u'\u00fa': 'uacute', u'\u00fb': 'ucircumflex', u'\u00fc': 'udiaeresis', u'\u00fd': 'yacute', u'\u00fe': 'thorn', u'\u00ff': 'ydiaeresis', u'\u0104': 'Aogonek', u'\u02d8': 'breve', u'\u0141': 'Lstroke', u'\u013d': 'Lcaron', u'\u015a': 'Sacute', u'\u0160': 'Scaron', u'\u015e': 'Scedilla', u'\u0164': 'Tcaron', u'\u0179': 'Zacute', u'\u017d': 'Zcaron', u'\u017b': 'Zabovedot', u'\u0105': 'aogonek', u'\u02db': 'ogonek', u'\u0142': 'lstroke', u'\u013e': 'lcaron', u'\u015b': 'sacute', u'\u02c7': 'caron', u'\u0161': 'scaron', u'\u015f': 'scedilla', u'\u0165': 'tcaron', u'\u017a': 'zacute', u'\u02dd': 'doubleacute', u'\u017e': 'zcaron', u'\u017c': 'zabovedot', u'\u0154': 'Racute', u'\u0102': 'Abreve', u'\u0139': 'Lacute', u'\u0106': 'Cacute', u'\u010c': 'Ccaron', u'\u0118': 'Eogonek', u'\u011a': 'Ecaron', u'\u010e': 'Dcaron', u'\u0110': 'Dstroke', u'\u0143': 'Nacute', u'\u0147': 'Ncaron', u'\u0150': 'Odoubleacute', u'\u0158': 'Rcaron', u'\u016e': 'Uring', u'\u0170': 'Udoubleacute', u'\u0162': 'Tcedilla', u'\u0155': 'racute', u'\u0103': 'abreve', u'\u013a': 'lacute', u'\u0107': 'cacute', u'\u010d': 'ccaron', u'\u0119': 'eogonek', u'\u011b': 'ecaron', u'\u010f': 'dcaron', u'\u0111': 'dstroke', u'\u0144': 'nacute', u'\u0148': 'ncaron', u'\u0151': 'odoubleacute', u'\u0159': 'rcaron', u'\u016f': 'uring', u'\u0171': 'udoubleacute', u'\u0163': 'tcedilla', u'\u02d9': 'abovedot', u'\u0126': 'Hstroke', u'\u0124': 'Hcircumflex', u'\u0130': 'Iabovedot', u'\u011e': 'Gbreve', u'\u0134': 'Jcircumflex', u'\u0127': 'hstroke', u'\u0125': 'hcircumflex', u'\u0131': 'idotless', u'\u011f': 'gbreve', u'\u0135': 'jcircumflex', u'\u010a': 'Cabovedot', u'\u0108': 'Ccircumflex', u'\u0120': 'Gabovedot', u'\u011c': 'Gcircumflex', u'\u016c': 'Ubreve', u'\u015c': 'Scircumflex', u'\u010b': 'cabovedot', u'\u0109': 'ccircumflex', u'\u0121': 'gabovedot', u'\u011d': 'gcircumflex', u'\u016d': 'ubreve', u'\u015d': 'scircumflex', u'\u0138': 'kra', u'\u0156': 'Rcedilla', u'\u0128': 'Itilde', u'\u013b': 'Lcedilla', u'\u0112': 'Emacron', u'\u0122': 'Gcedilla', u'\u0166': 'Tslash', u'\u0157': 'rcedilla', u'\u0129': 'itilde', u'\u013c': 'lcedilla', u'\u0113': 'emacron', u'\u0123': 'gcedilla', u'\u0167': 'tslash', u'\u014a': 'ENG', u'\u014b': 'eng', u'\u0100': 'Amacron', u'\u012e': 'Iogonek', u'\u0116': 'Eabovedot', u'\u012a': 'Imacron', u'\u0145': 'Ncedilla', u'\u014c': 'Omacron', u'\u0136': 'Kcedilla', u'\u0172': 'Uogonek', u'\u0168': 'Utilde', u'\u016a': 'Umacron', u'\u0101': 'amacron', u'\u012f': 'iogonek', u'\u0117': 'eabovedot', u'\u012b': 'imacron', u'\u0146': 'ncedilla', u'\u014d': 'omacron', u'\u0137': 'kcedilla', u'\u0173': 'uogonek', u'\u0169': 'utilde', u'\u016b': 'umacron', u'\u203e': 'overline', u'\u3002': 'kana_fullstop', u'\u300c': 'kana_openingbracket', u'\u300d': 'kana_closingbracket', u'\u3001': 'kana_comma', u'\u30fb': 'kana_conjunctive', u'\u30f2': 'kana_WO', u'\u30a1': 'kana_a', u'\u30a3': 'kana_i', u'\u30a5': 'kana_u', u'\u30a7': 'kana_e', u'\u30a9': 'kana_o', u'\u30e3': 'kana_ya', u'\u30e5': 'kana_yu', u'\u30e7': 'kana_yo', u'\u30c3': 'kana_tsu', u'\u30fc': 'prolongedsound', u'\u30a2': 'kana_A', u'\u30a4': 'kana_I', u'\u30a6': 'kana_U', u'\u30a8': 'kana_E', u'\u30aa': 'kana_O', u'\u30ab': 'kana_KA', u'\u30ad': 'kana_KI', u'\u30af': 'kana_KU', u'\u30b1': 'kana_KE', u'\u30b3': 'kana_KO', u'\u30b5': 'kana_SA', u'\u30b7': 'kana_SHI', u'\u30b9': 'kana_SU', u'\u30bb': 'kana_SE', u'\u30bd': 'kana_SO', u'\u30bf': 'kana_TA', u'\u30c1': 'kana_CHI', u'\u30c4': 'kana_TSU', u'\u30c6': 'kana_TE', u'\u30c8': 'kana_TO', u'\u30ca': 'kana_NA', u'\u30cb': 'kana_NI', u'\u30cc': 'kana_NU', u'\u30cd': 'kana_NE', u'\u30ce': 'kana_NO', u'\u30cf': 'kana_HA', u'\u30d2': 'kana_HI', u'\u30d5': 'kana_FU', u'\u30d8': 'kana_HE', u'\u30db': 'kana_HO', u'\u30de': 'kana_MA', u'\u30df': 'kana_MI', u'\u30e0': 'kana_MU', u'\u30e1': 'kana_ME', u'\u30e2': 'kana_MO', u'\u30e4': 'kana_YA', u'\u30e6': 'kana_YU', u'\u30e8': 'kana_YO', u'\u30e9': 'kana_RA', u'\u30ea': 'kana_RI', u'\u30eb': 'kana_RU', u'\u30ec': 'kana_RE', u'\u30ed': 'kana_RO', u'\u30ef': 'kana_WA', u'\u30f3': 'kana_N', u'\u309b': 'voicedsound', u'\u309c': 'semivoicedsound', u'\u060c': 'Arabic_comma', u'\u061b': 'Arabic_semicolon', u'\u061f': 'Arabic_question_mark', u'\u0621': 'Arabic_hamza', u'\u0622': 'Arabic_maddaonalef', u'\u0623': 'Arabic_hamzaonalef', u'\u0624': 'Arabic_hamzaonwaw', u'\u0625': 'Arabic_hamzaunderalef', u'\u0626': 'Arabic_hamzaonyeh', u'\u0627': 'Arabic_alef', u'\u0628': 'Arabic_beh', u'\u0629': 'Arabic_tehmarbuta', u'\u062a': 'Arabic_teh', u'\u062b': 'Arabic_theh', u'\u062c': 'Arabic_jeem', u'\u062d': 'Arabic_hah', u'\u062e': 'Arabic_khah', u'\u062f': 'Arabic_dal', u'\u0630': 'Arabic_thal', u'\u0631': 'Arabic_ra', u'\u0632': 'Arabic_zain', u'\u0633': 'Arabic_seen', u'\u0634': 'Arabic_sheen', u'\u0635': 'Arabic_sad', u'\u0636': 'Arabic_dad', u'\u0637': 'Arabic_tah', u'\u0638': 'Arabic_zah', u'\u0639': 'Arabic_ain', u'\u063a': 'Arabic_ghain', u'\u0640': 'Arabic_tatweel', u'\u0641': 'Arabic_feh', u'\u0642': 'Arabic_qaf', u'\u0643': 'Arabic_kaf', u'\u0644': 'Arabic_lam', u'\u0645': 'Arabic_meem', u'\u0646': 'Arabic_noon', u'\u0647': 'Arabic_ha', u'\u0648': 'Arabic_waw', u'\u0649': 'Arabic_alefmaksura', u'\u064a': 'Arabic_yeh', u'\u064b': 'Arabic_fathatan', u'\u064c': 'Arabic_dammatan', u'\u064d': 'Arabic_kasratan', u'\u064e': 'Arabic_fatha', u'\u064f': 'Arabic_damma', u'\u0650': 'Arabic_kasra', u'\u0651': 'Arabic_shadda', u'\u0652': 'Arabic_sukun', u'\u0452': 'Serbian_dje', u'\u0453': 'Macedonia_gje', u'\u0451': 'Cyrillic_io', u'\u0454': 'Ukrainian_ie', u'\u0455': 'Macedonia_dse', u'\u0456': 'Ukrainian_i', u'\u0457': 'Ukrainian_yi', u'\u0458': 'Cyrillic_je', u'\u0459': 'Cyrillic_lje', u'\u045a': 'Cyrillic_nje', u'\u045b': 'Serbian_tshe', u'\u045c': 'Macedonia_kje', u'\u045e': 'Byelorussian_shortu', u'\u045f': 'Cyrillic_dzhe', u'\u2116': 'numerosign', u'\u0402': 'Serbian_DJE', u'\u0403': 'Macedonia_GJE', u'\u0401': 'Cyrillic_IO', u'\u0404': 'Ukrainian_IE', u'\u0405': 'Macedonia_DSE', u'\u0406': 'Ukrainian_I', u'\u0407': 'Ukrainian_YI', u'\u0408': 'Cyrillic_JE', u'\u0409': 'Cyrillic_LJE', u'\u040a': 'Cyrillic_NJE', u'\u040b': 'Serbian_TSHE', u'\u040c': 'Macedonia_KJE', u'\u040e': 'Byelorussian_SHORTU', u'\u040f': 'Cyrillic_DZHE', u'\u044e': 'Cyrillic_yu', u'\u0430': 'Cyrillic_a', u'\u0431': 'Cyrillic_be', u'\u0446': 'Cyrillic_tse', u'\u0434': 'Cyrillic_de', u'\u0435': 'Cyrillic_ie', u'\u0444': 'Cyrillic_ef', u'\u0433': 'Cyrillic_ghe', u'\u0445': 'Cyrillic_ha', u'\u0438': 'Cyrillic_i', u'\u0439': 'Cyrillic_shorti', u'\u043a': 'Cyrillic_ka', u'\u043b': 'Cyrillic_el', u'\u043c': 'Cyrillic_em', u'\u043d': 'Cyrillic_en', u'\u043e': 'Cyrillic_o', u'\u043f': 'Cyrillic_pe', u'\u044f': 'Cyrillic_ya', u'\u0440': 'Cyrillic_er', u'\u0441': 'Cyrillic_es', u'\u0442': 'Cyrillic_te', u'\u0443': 'Cyrillic_u', u'\u0436': 'Cyrillic_zhe', u'\u0432': 'Cyrillic_ve', u'\u044c': 'Cyrillic_softsign', u'\u044b': 'Cyrillic_yeru', u'\u0437': 'Cyrillic_ze', u'\u0448': 'Cyrillic_sha', u'\u044d': 'Cyrillic_e', u'\u0449': 'Cyrillic_shcha', u'\u0447': 'Cyrillic_che', u'\u044a': 'Cyrillic_hardsign', u'\u042e': 'Cyrillic_YU', u'\u0410': 'Cyrillic_A', u'\u0411': 'Cyrillic_BE', u'\u0426': 'Cyrillic_TSE', u'\u0414': 'Cyrillic_DE', u'\u0415': 'Cyrillic_IE', u'\u0424': 'Cyrillic_EF', u'\u0413': 'Cyrillic_GHE', u'\u0425': 'Cyrillic_HA', u'\u0418': 'Cyrillic_I', u'\u0419': 'Cyrillic_SHORTI', u'\u041a': 'Cyrillic_KA', u'\u041b': 'Cyrillic_EL', u'\u041c': 'Cyrillic_EM', u'\u041d': 'Cyrillic_EN', u'\u041e': 'Cyrillic_O', u'\u041f': 'Cyrillic_PE', u'\u042f': 'Cyrillic_YA', u'\u0420': 'Cyrillic_ER', u'\u0421': 'Cyrillic_ES', u'\u0422': 'Cyrillic_TE', u'\u0423': 'Cyrillic_U', u'\u0416': 'Cyrillic_ZHE', u'\u0412': 'Cyrillic_VE', u'\u042c': 'Cyrillic_SOFTSIGN', u'\u042b': 'Cyrillic_YERU', u'\u0417': 'Cyrillic_ZE', u'\u0428': 'Cyrillic_SHA', u'\u042d': 'Cyrillic_E', u'\u0429': 'Cyrillic_SHCHA', u'\u0427': 'Cyrillic_CHE', u'\u042a': 'Cyrillic_HARDSIGN', u'\u0386': 'Greek_ALPHAaccent', u'\u0388': 'Greek_EPSILONaccent', u'\u0389': 'Greek_ETAaccent', u'\u038a': 'Greek_IOTAaccent', u'\u03aa': 'Greek_IOTAdiaeresis', u'\u038c': 'Greek_OMICRONaccent', u'\u038e': 'Greek_UPSILONaccent', u'\u03ab': 'Greek_UPSILONdieresis', u'\u038f': 'Greek_OMEGAaccent', u'\u0385': 'Greek_accentdieresis', u'\u2015': 'Greek_horizbar', u'\u03ac': 'Greek_alphaaccent', u'\u03ad': 'Greek_epsilonaccent', u'\u03ae': 'Greek_etaaccent', u'\u03af': 'Greek_iotaaccent', u'\u03ca': 'Greek_iotadieresis', u'\u0390': 'Greek_iotaaccentdieresis', u'\u03cc': 'Greek_omicronaccent', u'\u03cd': 'Greek_upsilonaccent', u'\u03cb': 'Greek_upsilondieresis', u'\u03b0': 'Greek_upsilonaccentdieresis', u'\u03ce': 'Greek_omegaaccent', u'\u0391': 'Greek_ALPHA', u'\u0392': 'Greek_BETA', u'\u0393': 'Greek_GAMMA', u'\u0394': 'Greek_DELTA', u'\u0395': 'Greek_EPSILON', u'\u0396': 'Greek_ZETA', u'\u0397': 'Greek_ETA', u'\u0398': 'Greek_THETA', u'\u0399': 'Greek_IOTA', u'\u039a': 'Greek_KAPPA', u'\u039b': 'Greek_LAMBDA', u'\u039b': 'Greek_LAMDA', u'\u039c': 'Greek_MU', u'\u039d': 'Greek_NU', u'\u039e': 'Greek_XI', u'\u039f': 'Greek_OMICRON', u'\u03a0': 'Greek_PI', u'\u03a1': 'Greek_RHO', u'\u03a3': 'Greek_SIGMA', u'\u03a4': 'Greek_TAU', u'\u03a5': 'Greek_UPSILON', u'\u03a6': 'Greek_PHI', u'\u03a7': 'Greek_CHI', u'\u03a8': 'Greek_PSI', u'\u03a9': 'Greek_OMEGA', u'\u03b1': 'Greek_alpha', u'\u03b2': 'Greek_beta', u'\u03b3': 'Greek_gamma', u'\u03b4': 'Greek_delta', u'\u03b5': 'Greek_epsilon', u'\u03b6': 'Greek_zeta', u'\u03b7': 'Greek_eta', u'\u03b8': 'Greek_theta', u'\u03b9': 'Greek_iota', u'\u03ba': 'Greek_kappa', u'\u03bb': 'Greek_lambda', u'\u03bc': 'Greek_mu', u'\u03bd': 'Greek_nu', u'\u03be': 'Greek_xi', u'\u03bf': 'Greek_omicron', u'\u03c0': 'Greek_pi', u'\u03c1': 'Greek_rho', u'\u03c3': 'Greek_sigma', u'\u03c2': 'Greek_finalsmallsigma', u'\u03c4': 'Greek_tau', u'\u03c5': 'Greek_upsilon', u'\u03c6': 'Greek_phi', u'\u03c7': 'Greek_chi', u'\u03c8': 'Greek_psi', u'\u03c9': 'Greek_omega', u'\u23b7': 'leftradical', u'\u2320': 'topintegral', u'\u2321': 'botintegral', u'\u23a1': 'topleftsqbracket', u'\u23a3': 'botleftsqbracket', u'\u23a4': 'toprightsqbracket', u'\u23a6': 'botrightsqbracket', u'\u239b': 'topleftparens', u'\u239d': 'botleftparens', u'\u239e': 'toprightparens', u'\u23a0': 'botrightparens', u'\u23a8': 'leftmiddlecurlybrace', u'\u23ac': 'rightmiddlecurlybrace', u'\u2264': 'lessthanequal', u'\u2260': 'notequal', u'\u2265': 'greaterthanequal', u'\u222b': 'integral', u'\u2234': 'therefore', u'\u221d': 'variation', u'\u221e': 'infinity', u'\u2207': 'nabla', u'\u223c': 'approximate', u'\u2243': 'similarequal', u'\u21d4': 'ifonlyif', u'\u21d2': 'implies', u'\u2261': 'identical', u'\u221a': 'radical', u'\u2282': 'includedin', u'\u2283': 'includes', u'\u2229': 'intersection', u'\u222a': 'union', u'\u2227': 'logicaland', u'\u2228': 'logicalor', u'\u2202': 'partialderivative', u'\u0192': 'function', u'\u2190': 'leftarrow', u'\u2191': 'uparrow', u'\u2192': 'rightarrow', u'\u2193': 'downarrow', u'\u25c6': 'soliddiamond', u'\u2592': 'checkerboard', u'\u2409': 'ht', u'\u240c': 'ff', u'\u240d': 'cr', u'\u240a': 'lf', u'\u2424': 'nl', u'\u240b': 'vt', u'\u2518': 'lowrightcorner', u'\u2510': 'uprightcorner', u'\u250c': 'upleftcorner', u'\u2514': 'lowleftcorner', u'\u253c': 'crossinglines', u'\u23ba': 'horizlinescan1', u'\u23bb': 'horizlinescan3', u'\u2500': 'horizlinescan5', u'\u23bc': 'horizlinescan7', u'\u23bd': 'horizlinescan9', u'\u251c': 'leftt', u'\u2524': 'rightt', u'\u2534': 'bott', u'\u252c': 'topt', u'\u2502': 'vertbar', u'\u2003': 'emspace', u'\u2002': 'enspace', u'\u2004': 'em3space', u'\u2005': 'em4space', u'\u2007': 'digitspace', u'\u2008': 'punctspace', u'\u2009': 'thinspace', u'\u200a': 'hairspace', u'\u2014': 'emdash', u'\u2013': 'endash', u'\u2026': 'ellipsis', u'\u2025': 'doubbaselinedot', u'\u2153': 'onethird', u'\u2154': 'twothirds', u'\u2155': 'onefifth', u'\u2156': 'twofifths', u'\u2157': 'threefifths', u'\u2158': 'fourfifths', u'\u2159': 'onesixth', u'\u215a': 'fivesixths', u'\u2105': 'careof', u'\u2012': 'figdash', u'\u215b': 'oneeighth', u'\u215c': 'threeeighths', u'\u215d': 'fiveeighths', u'\u215e': 'seveneighths', u'\u2122': 'trademark', u'\u2018': 'leftsinglequotemark', u'\u2019': 'rightsinglequotemark', u'\u201c': 'leftdoublequotemark', u'\u201d': 'rightdoublequotemark', u'\u211e': 'prescription', u'\u2032': 'minutes', u'\u2033': 'seconds', u'\u271d': 'latincross', u'\u2663': 'club', u'\u2666': 'diamond', u'\u2665': 'heart', u'\u2720': 'maltesecross', u'\u2020': 'dagger', u'\u2021': 'doubledagger', u'\u2713': 'checkmark', u'\u2717': 'ballotcross', u'\u266f': 'musicalsharp', u'\u266d': 'musicalflat', u'\u2642': 'malesymbol', u'\u2640': 'femalesymbol', u'\u260e': 'telephone', u'\u2315': 'telephonerecorder', u'\u2117': 'phonographcopyright', u'\u2038': 'caret', u'\u201a': 'singlelowquotemark', u'\u201e': 'doublelowquotemark', u'\u22a5': 'downtack', u'\u230a': 'downstile', u'\u2218': 'jot', u'\u2395': 'quad', u'\u22a4': 'uptack', u'\u25cb': 'circle', u'\u2308': 'upstile', u'\u22a2': 'lefttack', u'\u22a3': 'righttack', u'\u2017': 'hebrew_doublelowline', u'\u05d0': 'hebrew_aleph', u'\u05d1': 'hebrew_bet', u'\u05d1': 'hebrew_beth', u'\u05d2': 'hebrew_gimel', u'\u05d2': 'hebrew_gimmel', u'\u05d3': 'hebrew_dalet', u'\u05d3': 'hebrew_daleth', u'\u05d4': 'hebrew_he', u'\u05d5': 'hebrew_waw', u'\u05d6': 'hebrew_zain', u'\u05d6': 'hebrew_zayin', u'\u05d7': 'hebrew_chet', u'\u05d7': 'hebrew_het', u'\u05d8': 'hebrew_tet', u'\u05d8': 'hebrew_teth', u'\u05d9': 'hebrew_yod', u'\u05da': 'hebrew_finalkaph', u'\u05db': 'hebrew_kaph', u'\u05dc': 'hebrew_lamed', u'\u05dd': 'hebrew_finalmem', u'\u05de': 'hebrew_mem', u'\u05df': 'hebrew_finalnun', u'\u05e0': 'hebrew_nun', u'\u05e1': 'hebrew_samech', u'\u05e1': 'hebrew_samekh', u'\u05e2': 'hebrew_ayin', u'\u05e3': 'hebrew_finalpe', u'\u05e4': 'hebrew_pe', u'\u05e5': 'hebrew_finalzade', u'\u05e5': 'hebrew_finalzadi', u'\u05e6': 'hebrew_zade', u'\u05e6': 'hebrew_zadi', u'\u05e7': 'hebrew_kuf', u'\u05e7': 'hebrew_qoph', u'\u05e8': 'hebrew_resh', u'\u05e9': 'hebrew_shin', u'\u05ea': 'hebrew_taf', u'\u05ea': 'hebrew_taw', u'\u0e01': 'Thai_kokai', u'\u0e02': 'Thai_khokhai', u'\u0e03': 'Thai_khokhuat', u'\u0e04': 'Thai_khokhwai', u'\u0e05': 'Thai_khokhon', u'\u0e06': 'Thai_khorakhang', u'\u0e07': 'Thai_ngongu', u'\u0e08': 'Thai_chochan', u'\u0e09': 'Thai_choching', u'\u0e0a': 'Thai_chochang', u'\u0e0b': 'Thai_soso', u'\u0e0c': 'Thai_chochoe', u'\u0e0d': 'Thai_yoying', u'\u0e0e': 'Thai_dochada', u'\u0e0f': 'Thai_topatak', u'\u0e10': 'Thai_thothan', u'\u0e11': 'Thai_thonangmontho', u'\u0e12': 'Thai_thophuthao', u'\u0e13': 'Thai_nonen', u'\u0e14': 'Thai_dodek', u'\u0e15': 'Thai_totao', u'\u0e16': 'Thai_thothung', u'\u0e17': 'Thai_thothahan', u'\u0e18': 'Thai_thothong', u'\u0e19': 'Thai_nonu', u'\u0e1a': 'Thai_bobaimai', u'\u0e1b': 'Thai_popla', u'\u0e1c': 'Thai_phophung', u'\u0e1d': 'Thai_fofa', u'\u0e1e': 'Thai_phophan', u'\u0e1f': 'Thai_fofan', u'\u0e20': 'Thai_phosamphao', u'\u0e21': 'Thai_moma', u'\u0e22': 'Thai_yoyak', u'\u0e23': 'Thai_rorua', u'\u0e24': 'Thai_ru', u'\u0e25': 'Thai_loling', u'\u0e26': 'Thai_lu', u'\u0e27': 'Thai_wowaen', u'\u0e28': 'Thai_sosala', u'\u0e29': 'Thai_sorusi', u'\u0e2a': 'Thai_sosua', u'\u0e2b': 'Thai_hohip', u'\u0e2c': 'Thai_lochula', u'\u0e2d': 'Thai_oang', u'\u0e2e': 'Thai_honokhuk', u'\u0e2f': 'Thai_paiyannoi', u'\u0e30': 'Thai_saraa', u'\u0e31': 'Thai_maihanakat', u'\u0e32': 'Thai_saraaa', u'\u0e33': 'Thai_saraam', u'\u0e34': 'Thai_sarai', u'\u0e35': 'Thai_saraii', u'\u0e36': 'Thai_saraue', u'\u0e37': 'Thai_sarauee', u'\u0e38': 'Thai_sarau', u'\u0e39': 'Thai_sarauu', u'\u0e3a': 'Thai_phinthu', u'\u0e3f': 'Thai_baht', u'\u0e40': 'Thai_sarae', u'\u0e41': 'Thai_saraae', u'\u0e42': 'Thai_sarao', u'\u0e43': 'Thai_saraaimaimuan', u'\u0e44': 'Thai_saraaimaimalai', u'\u0e45': 'Thai_lakkhangyao', u'\u0e46': 'Thai_maiyamok', u'\u0e47': 'Thai_maitaikhu', u'\u0e48': 'Thai_maiek', u'\u0e49': 'Thai_maitho', u'\u0e4a': 'Thai_maitri', u'\u0e4b': 'Thai_maichattawa', u'\u0e4c': 'Thai_thanthakhat', u'\u0e4d': 'Thai_nikhahit', u'\u0e50': 'Thai_leksun', u'\u0e51': 'Thai_leknung', u'\u0e52': 'Thai_leksong', u'\u0e53': 'Thai_leksam', u'\u0e54': 'Thai_leksi', u'\u0e55': 'Thai_lekha', u'\u0e56': 'Thai_lekhok', u'\u0e57': 'Thai_lekchet', u'\u0e58': 'Thai_lekpaet', u'\u0e59': 'Thai_lekkao', u'\u0152': 'OE', u'\u0153': 'oe', u'\u0178': 'Ydiaeresis', u'\u20ac': 'EuroSign', u'\u0491': 'Ukrainian_ghe_with_upturn', u'\u0490': 'Ukrainian_GHE_WITH_UPTURN'} ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617681733.332567 PyUserInput-0.1.12/pymouse/0002755000174500001730000000000000000000000015262 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/__init__.py0000644000174500001730000000251300000000000017372 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . """ The goal of PyMouse is to have a cross-platform way to control the mouse. PyMouse should work on Windows, Mac and any Unix that has xlib. PyMouse is a part of PyUserInput, along with PyKeyboard, for more information about this project, see: http://github.com/SavinaRoja/PyUserInput PyMouse was originally developed by Pepijn de Vos. For the original repository, see: https://github.com/pepijndevos/PyMouse """ import sys if sys.platform.startswith('java'): from .java_ import PyMouse elif sys.platform == 'darwin': from .mac import PyMouse, PyMouseEvent elif sys.platform == 'win32': from .windows import PyMouse, PyMouseEvent else: from .x11 import PyMouse, PyMouseEvent ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/base.py0000644000174500001730000000771700000000000016560 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . """ The goal of PyMouse is to have a cross-platform way to control the mouse. PyMouse should work on Windows, Mac and any Unix that has xlib. As the base file, this provides a rough operational model along with the framework to be extended by each platform. """ from threading import Thread class ScrollSupportError(Exception): pass class PyMouseMeta(object): def press(self, x, y, button=1): """ Press the mouse on a given x, y and button. Button is defined as 1 = left, 2 = right, 3 = middle. """ raise NotImplementedError def release(self, x, y, button=1): """ Release the mouse on a given x, y and button. Button is defined as 1 = left, 2 = right, 3 = middle. """ raise NotImplementedError def click(self, x, y, button=1, n=1): """ Click a mouse button n times on a given x, y. Button is defined as 1 = left, 2 = right, 3 = middle. """ for i in range(n): self.press(x, y, button) self.release(x, y, button) def scroll(self, vertical=None, horizontal=None, depth=None): """ Generates mouse scrolling events in up to three dimensions: vertical, horizontal, and depth (Mac-only). Values for these arguments may be positive or negative numbers (float or int). Refer to the following: Vertical: + Up, - Down Horizontal: + Right, - Left Depth: + Rise (out of display), - Dive (towards display) Dynamic scrolling, which is used Windows and Mac platforms, is not implemented at this time due to an inability to test Mac code. The events generated by this code will thus be discrete units of scrolling "lines". The user is advised to take care at all times with scrolling automation as scrolling event consumption is relatively un-standardized. Float values will be coerced to integers. """ raise NotImplementedError def move(self, x, y): """Move the mouse to a given x and y""" raise NotImplementedError def drag(self, x, y): """Drag the mouse to a given x and y. A Drag is a Move where the mouse key is held down.""" raise NotImplementedError def position(self): """ Get the current mouse position in pixels. Returns a tuple of 2 integers """ raise NotImplementedError def screen_size(self): """ Get the current screen size in pixels. Returns a tuple of 2 integers """ raise NotImplementedError class PyMouseEventMeta(Thread): def __init__(self, capture=False, capture_move=False): Thread.__init__(self) self.daemon = True self.capture = capture self.capture_move = capture_move self.state = True def stop(self): self.state = False def click(self, x, y, button, press): """Subclass this method with your click event handler""" pass def move(self, x, y): """Subclass this method with your move event handler""" pass def scroll(self, x, y, vertical, horizontal): """ Subclass this method with your scroll event handler Vertical: + Up, - Down Horizontal: + Right, - Left """ pass ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/java_.py0000644000174500001730000000303400000000000016712 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . from java.awt import Robot, Toolkit from java.awt.event import InputEvent from java.awt.MouseInfo import getPointerInfo from .base import PyMouseMeta r = Robot() class PyMouse(PyMouseMeta): def press(self, x, y, button = 1): button_list = [None, InputEvent.BUTTON1_MASK, InputEvent.BUTTON3_MASK, InputEvent.BUTTON2_MASK] self.move(x, y) r.mousePress(button_list[button]) def release(self, x, y, button = 1): button_list = [None, InputEvent.BUTTON1_MASK, InputEvent.BUTTON3_MASK, InputEvent.BUTTON2_MASK] self.move(x, y) r.mouseRelease(button_list[button]) def move(self, x, y): r.mouseMove(x, y) def position(self): loc = getPointerInfo().getLocation() return loc.getX, loc.getY def screen_size(self): dim = Toolkit.getDefaultToolkit().getScreenSize() return dim.getWidth(), dim.getHeight() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/mac.py0000644000174500001730000001265300000000000016401 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . import Quartz from AppKit import NSEvent, NSScreen from .base import PyMouseMeta, PyMouseEventMeta pressID = [None, Quartz.kCGEventLeftMouseDown, Quartz.kCGEventRightMouseDown, Quartz.kCGEventOtherMouseDown] releaseID = [None, Quartz.kCGEventLeftMouseUp, Quartz.kCGEventRightMouseUp, Quartz.kCGEventOtherMouseUp] class PyMouse(PyMouseMeta): def press(self, x, y, button=1): event = Quartz.CGEventCreateMouseEvent(None, pressID[button], (x, y), button - 1) Quartz.CGEventPost(Quartz.kCGHIDEventTap, event) def release(self, x, y, button=1): event = Quartz.CGEventCreateMouseEvent(None, releaseID[button], (x, y), button - 1) Quartz.CGEventPost(Quartz.kCGHIDEventTap, event) def move(self, x, y): move = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventMouseMoved, (x, y), 0) Quartz.CGEventPost(Quartz.kCGHIDEventTap, move) def drag(self, x, y): drag = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseDragged, (x, y), 0) Quartz.CGEventPost(Quartz.kCGHIDEventTap, drag) def position(self): loc = NSEvent.mouseLocation() return loc.x, Quartz.CGDisplayPixelsHigh(0) - loc.y def screen_size(self): return NSScreen.mainScreen().frame().size.width, NSScreen.mainScreen().frame().size.height def scroll(self, vertical=None, horizontal=None, depth=None): #Local submethod for generating Mac scroll events in one axis at a time def scroll_event(y_move=0, x_move=0, z_move=0, n=1): for _ in range(abs(n)): scrollWheelEvent = Quartz.CGEventCreateScrollWheelEvent( None, # No source Quartz.kCGScrollEventUnitLine, # Unit of measurement is lines 3, # Number of wheels(dimensions) y_move, x_move, z_move) Quartz.CGEventPost(Quartz.kCGHIDEventTap, scrollWheelEvent) #Execute vertical then horizontal then depth scrolling events if vertical is not None: vertical = int(vertical) if vertical == 0: # Do nothing with 0 distance pass elif vertical > 0: # Scroll up if positive scroll_event(y_move=1, n=vertical) else: # Scroll down if negative scroll_event(y_move=-1, n=abs(vertical)) if horizontal is not None: horizontal = int(horizontal) if horizontal == 0: # Do nothing with 0 distance pass elif horizontal > 0: # Scroll right if positive scroll_event(x_move=1, n=horizontal) else: # Scroll left if negative scroll_event(x_move=-1, n=abs(horizontal)) if depth is not None: depth = int(depth) if depth == 0: # Do nothing with 0 distance pass elif vertical > 0: # Scroll "out" if positive scroll_event(z_move=1, n=depth) else: # Scroll "in" if negative scroll_event(z_move=-1, n=abs(depth)) class PyMouseEvent(PyMouseEventMeta): def run(self): tap = Quartz.CGEventTapCreate( Quartz.kCGSessionEventTap, Quartz.kCGHeadInsertEventTap, Quartz.kCGEventTapOptionDefault, Quartz.CGEventMaskBit(Quartz.kCGEventMouseMoved) | Quartz.CGEventMaskBit(Quartz.kCGEventLeftMouseDown) | Quartz.CGEventMaskBit(Quartz.kCGEventLeftMouseUp) | Quartz.CGEventMaskBit(Quartz.kCGEventRightMouseDown) | Quartz.CGEventMaskBit(Quartz.kCGEventRightMouseUp) | Quartz.CGEventMaskBit(Quartz.kCGEventOtherMouseDown) | Quartz.CGEventMaskBit(Quartz.kCGEventOtherMouseUp), self.handler, None) loopsource = Quartz.CFMachPortCreateRunLoopSource(None, tap, 0) loop = Quartz.CFRunLoopGetCurrent() Quartz.CFRunLoopAddSource(loop, loopsource, Quartz.kCFRunLoopDefaultMode) Quartz.CGEventTapEnable(tap, True) while self.state: Quartz.CFRunLoopRunInMode(Quartz.kCFRunLoopDefaultMode, 5, False) def handler(self, proxy, type, event, refcon): (x, y) = Quartz.CGEventGetLocation(event) if type in pressID: self.click(x, y, pressID.index(type), True) elif type in releaseID: self.click(x, y, releaseID.index(type), False) else: self.move(x, y) if self.capture: Quartz.CGEventSetType(event, Quartz.kCGEventNull) return event ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/mir.py0000644000174500001730000000121600000000000016421 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/wayland.py0000644000174500001730000000121600000000000017271 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/windows.py0000644000174500001730000001141300000000000017324 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . from ctypes import * import win32api import win32con from .base import PyMouseMeta, PyMouseEventMeta, ScrollSupportError import pythoncom from time import sleep class POINT(Structure): _fields_ = [("x", c_long), ("y", c_long)] class PyMouse(PyMouseMeta): """MOUSEEVENTF_(button and action) constants are defined at win32con, buttonAction is that value""" def press(self, x, y, button=1): buttonAction = 2 ** ((2 * button) - 1) self.move(x, y) win32api.mouse_event(buttonAction, x, y) def release(self, x, y, button=1): buttonAction = 2 ** ((2 * button)) self.move(x, y) win32api.mouse_event(buttonAction, x, y) def scroll(self, vertical=None, horizontal=None, depth=None): #Windows supports only vertical and horizontal scrolling if depth is not None: raise ScrollSupportError('PyMouse cannot support depth-scrolling \ in Windows. This feature is only available on Mac.') #Execute vertical then horizontal scrolling events if vertical is not None: vertical = int(vertical) if vertical == 0: # Do nothing with 0 distance pass elif vertical > 0: # Scroll up if positive for _ in range(vertical): win32api.mouse_event(0x0800, 0, 0, 120, 0) else: # Scroll down if negative for _ in range(abs(vertical)): win32api.mouse_event(0x0800, 0, 0, -120, 0) if horizontal is not None: horizontal = int(horizontal) if horizontal == 0: # Do nothing with 0 distance pass elif horizontal > 0: # Scroll right if positive for _ in range(horizontal): win32api.mouse_event(0x01000, 0, 0, 120, 0) else: # Scroll left if negative for _ in range(abs(horizontal)): win32api.mouse_event(0x01000, 0, 0, -120, 0) def move(self, x, y): windll.user32.SetCursorPos(x, y) def drag(self, x, y): self.press(*self.position()) #self.move(x, y) self.release(x, y) def position(self): pt = POINT() windll.user32.GetCursorPos(byref(pt)) return pt.x, pt.y def screen_size(self): if windll.user32.GetSystemMetrics(80) == 1: width = windll.user32.GetSystemMetrics(0) height = windll.user32.GetSystemMetrics(1) else: width = windll.user32.GetSystemMetrics(78) height = windll.user32.GetSystemMetrics(79) return width, height class PyMouseEvent(PyMouseEventMeta): def __init__(self, capture=False, capture_move=False): import pyHook PyMouseEventMeta.__init__(self, capture=capture, capture_move=capture_move) self.hm = pyHook.HookManager() def run(self): self.hm.MouseAll = self._action self.hm.HookMouse() while self.state: sleep(0.01) pythoncom.PumpWaitingMessages() def stop(self): self.hm.UnhookMouse() self.state = False def _action(self, event): import pyHook x, y = event.Position if event.Message == pyHook.HookConstants.WM_MOUSEMOVE: self.move(x,y) return not self.capture_move elif event.Message == pyHook.HookConstants.WM_LBUTTONDOWN: self.click(x, y, 1, True) elif event.Message == pyHook.HookConstants.WM_LBUTTONUP: self.click(x, y, 1, False) elif event.Message == pyHook.HookConstants.WM_RBUTTONDOWN: self.click(x, y, 2, True) elif event.Message == pyHook.HookConstants.WM_RBUTTONUP: self.click(x, y, 2, False) elif event.Message == pyHook.HookConstants.WM_MBUTTONDOWN: self.click(x, y, 3, True) elif event.Message == pyHook.HookConstants.WM_MBUTTONUP: self.click(x, y, 3, False) elif event.Message == pyHook.HookConstants.WM_MOUSEWHEEL: # event.Wheel is -1 when scrolling down, 1 when scrolling up self.scroll(x, y, event.Wheel, 0) return not self.capture ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/pymouse/x11.py0000644000174500001730000001760100000000000016250 0ustar00janitorsbuild#Copyright 2013 Paul Barton # #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU 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 General Public License for more details. # #You should have received a copy of the GNU General Public License #along with this program. If not, see . from Xlib.display import Display from Xlib import X from Xlib.ext.xtest import fake_input from Xlib.ext import record from Xlib.protocol import rq from .base import PyMouseMeta, PyMouseEventMeta, ScrollSupportError 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 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 """ from contextlib import contextmanager @contextmanager def manager(): errors = [] def handler(*args): errors.append(args) old_handler = display.set_error_handler(handler) yield display display.sync() display.set_error_handler(old_handler) if errors: raise X11Error(errors) return manager() def translate_button_code(button): # In X11, the button numbers are: # leftclick=1, middleclick=2, rightclick=3 # For the purposes of the cross-platform interface of PyMouse, we # invert the button number values of the right and middle buttons if button in [1, 2, 3]: return (None, 1, 3, 2)[button] else: return button def button_code_to_scroll_direction(button): # scrollup=4, scrolldown=5, scrollleft=6, scrollright=7 return { 4: (1, 0), 5: (-1, 0), 6: (0, 1), 7: (0, -1), }[button] class PyMouse(PyMouseMeta): def __init__(self, display=None): PyMouseMeta.__init__(self) self.display = Display(display) self.display2 = Display(display) def press(self, x, y, button=1): self.move(x, y) with display_manager(self.display) as d: fake_input(d, X.ButtonPress, translate_button_code(button)) def release(self, x, y, button=1): self.move(x, y) with display_manager(self.display) as d: fake_input(d, X.ButtonRelease, translate_button_code(button)) def scroll(self, vertical=None, horizontal=None, depth=None): #Xlib supports only vertical and horizontal scrolling if depth is not None: raise ScrollSupportError('PyMouse cannot support depth-scrolling \ in X11. This feature is only available on Mac.') #Execute vertical then horizontal scrolling events if vertical is not None: vertical = int(vertical) if vertical == 0: # Do nothing with 0 distance pass elif vertical > 0: # Scroll up if positive self.click(*self.position(), button=4, n=vertical) else: # Scroll down if negative self.click(*self.position(), button=5, n=abs(vertical)) if horizontal is not None: horizontal = int(horizontal) if horizontal == 0: # Do nothing with 0 distance pass elif horizontal > 0: # Scroll right if positive self.click(*self.position(), button=7, n=horizontal) else: # Scroll left if negative self.click(*self.position(), button=6, n=abs(horizontal)) def move(self, x, y): if (x, y) != self.position(): with display_manager(self.display) as d: fake_input(d, X.MotionNotify, x=x, y=y) def drag(self, x, y): with display_manager(self.display) as d: fake_input(d, X.ButtonPress, 1) fake_input(d, X.MotionNotify, x=x, y=y) fake_input(d, X.ButtonRelease, 1) def position(self): coord = self.display.screen().root.query_pointer()._data return coord["root_x"], coord["root_y"] def screen_size(self): width = self.display.screen().width_in_pixels height = self.display.screen().height_in_pixels return width, height class PyMouseEvent(PyMouseEventMeta): def __init__(self, capture=False, capture_move=False, display=None): PyMouseEventMeta.__init__(self, capture=capture, capture_move=capture_move) self.display = Display(display) self.display2 = Display(display) self.ctx = self.display2.record_create_context( 0, [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': (X.ButtonPressMask, X.ButtonReleaseMask), 'errors': (0, 0), 'client_started': False, 'client_died': False, }]) def run(self): try: if self.capture and self.capture_move: capturing = X.ButtonPressMask | X.ButtonReleaseMask | X.PointerMotionMask elif self.capture: capturing = X.ButtonPressMask | X.ButtonReleaseMask elif self.capture_move: capturing = X.PointerMotionMask else: capturing = False if capturing: self.display2.screen().root.grab_pointer(True, capturing, X.GrabModeAsync, X.GrabModeAsync, 0, 0, X.CurrentTime) self.display.screen().root.grab_pointer(True, capturing, X.GrabModeAsync, X.GrabModeAsync, 0, 0, X.CurrentTime) self.display2.record_enable_context(self.ctx, self.handler) self.display2.record_free_context(self.ctx) except KeyboardInterrupt: self.stop() def stop(self): self.state = False with display_manager(self.display) as d: d.ungrab_pointer(X.CurrentTime) d.record_disable_context(self.ctx) self.display2.ungrab_pointer(X.CurrentTime) self.display2.record_disable_context(self.ctx) def handler(self, reply): data = reply.data while len(data): event, data = rq.EventField(None).parse_binary_value(data, self.display.display, None, None) if event.detail in [4, 5, 6, 7]: if event.type == X.ButtonPress: self.scroll(event.root_x, event.root_y, *button_code_to_scroll_direction(event.detail)) elif event.type == X.ButtonPress: self.click(event.root_x, event.root_y, translate_button_code(event.detail), True) elif event.type == X.ButtonRelease: self.click(event.root_x, event.root_y, translate_button_code(event.detail), False) else: self.move(event.root_x, event.root_y) ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617681733.332567 PyUserInput-0.1.12/setup.cfg0000644000174500001730000000004600000000000015400 0ustar00janitorsbuild[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617681731.0 PyUserInput-0.1.12/setup.py0000644000174500001730000000230000000000000015264 0ustar00janitorsbuildtry: from setuptools import setup except ImportError: from distutils.core import setup import os import sys def long_description(): readme = os.path.join(os.path.dirname(__file__), 'README.md') with open(readme, 'r') as inf: readme_text = inf.read() return(readme_text) #Check for dependencies dependencies = [] if sys.platform == 'darwin': # Mac dependencies.append('pyobjc-framework-Quartz') elif sys.platform == 'win32': # Windows dependencies.extend(['pyHook', 'pypiwin32']) else: # X11 (LInux) dependencies.append('python-xlib') setup(name='PyUserInput', version='0.1.12', description='A simple, cross-platform module for mouse and keyboard control', long_description=long_description(), author='Paul Barton , Pepijn de Vos ', author_email='pablo.barton@gmail.com', # Replace with mailing list perhaps url='https://github.com/PyUserInput/PyUserInput', package_dir = {'': '.'}, packages = ['pykeyboard', 'pymouse'], license='http://www.gnu.org/licenses/gpl-3.0.html', keywords='mouse,keyboard user input event', install_requires=dependencies, )