nc@sWdZddlmZdZddlZddlZddl Z ddl m Z mZddlZeeddpzeje_yBeefddZd dZddlZdd l mZWnFek r d dZd dZddlZdd l mZYnXddZGddde Z!GdddeZddl"Z#e#j$dkrtddl%m&Z'n~e#j$dkrddl%m(Z'nYe#j$dkryddl%m)Z'Wqe*k rYqXne+dj,e#j$ddl-m.Z.m/Z/m0Z0ddl1m2Z3ddl4m5Z5m6Z6m7Z7e8Z9ddZ:eZ;iZ<e<Z=iZ>Gd d!d!e3Z?e?Z@d"d#d$ZAd%d&ZBd"d"d'd(ZCeCZDd)d*ZEd+d,ZFd-d.ZGfd/d0d1ZHiZId2d3dd4d5ZJd2d6d7ZKd2d8d9ZLd2d:d;ZMd2d<d=ZNd2d>d?ZOd@dAZPePZQdBdCZRdDdEZSeQZTdFdGZUeQZVdHdIZWdJdKZXiZYfd2dd2dLdMZZeZZ[dNdOZ\e\Z]Z^dPdQZ_e_Z`ZaZbd"d2dRdSZce\ZddTdUZedVdWZfdXdYZgdd"ddZd[Zhdd2d2d\d]Zidd^d_Zjd2d`daZkd2dbdcZld"dddeZmd"dfdgZndaoddhdiZpdjdkZqdld2d2dmdnZrdodpdqZsesZtiZudrgd2dsdtduZvdvdwZwd2dsdxdyZxevZyexZzewZ{dS)zu8 keyboard ======== Take full control of your keyboard with this small Python library. Hook global events, register hotkeys, simulate key presses and much more. ## Features - **Global event hook** on all keyboards (captures keys regardless of focus). - **Listen** and **send** keyboard events. - Works with **Windows** and **Linux** (requires sudo), with experimental **OS X** support (thanks @glitchassassin!). - **Pure Python**, no C modules to be compiled. - **Zero dependencies**. Trivial to install and deploy, just copy the files. - **Python 2 and 3**. - Complex hotkey support (e.g. `ctrl+shift+m, ctrl+space`) with controllable timeout. - Includes **high level API** (e.g. [record](#keyboard.record) and [play](#keyboard.play), [add_abbreviation](#keyboard.add_abbreviation)). - Maps keys as they actually are in your layout, with **full internationalization support** (e.g. `Ctrl+ç`). - Events automatically captured in separate thread, doesn't block main program. - Tested and documented. - Doesn't break accented dead keys (I'm looking at you, pyHook). - Mouse support available via project [mouse](https://github.com/boppreh/mouse) (`pip install mouse`). ## Usage Install the [PyPI package](https://pypi.python.org/pypi/keyboard/): pip install keyboard or clone the repository (no installation required, source files are sufficient): git clone https://github.com/boppreh/keyboard or [download and extract the zip](https://github.com/boppreh/keyboard/archive/master.zip) into your project folder. Then check the [API docs below](https://github.com/boppreh/keyboard#api) to see what features are available. ## Example Use as library: ```py import keyboard keyboard.press_and_release('shift+s, space') keyboard.write('The quick brown fox jumps over the lazy dog.') keyboard.add_hotkey('ctrl+shift+a', print, args=('triggered', 'hotkey')) # Press PAGE UP then PAGE DOWN to type "foobar". keyboard.add_hotkey('page up, page down', lambda: keyboard.write('foobar')) # Blocks until you press esc. keyboard.wait('esc') # Record events until 'esc' is pressed. recorded = keyboard.record(until='esc') # Then replay back at three times the speed. keyboard.play(recorded, speed_factor=3) # Type @@ then press space to replace with abbreviation. keyboard.add_abbreviation('@@', 'my.long.email@example.com') # Block forever, like `while True`. keyboard.wait() ``` Use as standalone module: ```bash # Save JSON events to a file until interrupted: python -m keyboard > events.txt cat events.txt # {"event_type": "down", "scan_code": 25, "name": "p", "time": 1622447562.2994788, "is_keypad": false} # {"event_type": "up", "scan_code": 25, "name": "p", "time": 1622447562.431007, "is_keypad": false} # ... # Replay events python -m keyboard < events.txt ``` ## Known limitations: - Events generated under Windows don't report device id (`event.device == None`). [#21](https://github.com/boppreh/keyboard/issues/21) - Media keys on Linux may appear nameless (scan-code only) or not at all. [#20](https://github.com/boppreh/keyboard/issues/20) - Key suppression/blocking only available on Windows. [#22](https://github.com/boppreh/keyboard/issues/22) - To avoid depending on X, the Linux parts reads raw device files (`/dev/input/input*`) but this requires root. - Other applications, such as some games, may register hooks that swallow all key events. In this case `keyboard` will be unable to report events. - This program makes no attempt to hide itself, so don't use it for keyloggers or online gaming bots. Be responsible. - SSH connections forward only the text typed, not keyboard events. Therefore if you connect to a server or Raspberry PI that is running `keyboard` via SSH, the server will not detect your key events. ## Common patterns and mistakes ### Preventing the program from closing ```py import keyboard keyboard.add_hotkey('space', lambda: print('space was pressed!')) # If the program finishes, the hotkey is not in effect anymore. # Don't do this! This will use 100% of your CPU. #while True: pass # Use this instead keyboard.wait() # or this import time while True: time.sleep(1000000) ``` ### Waiting for a key press one time ```py import keyboard # Don't do this! This will use 100% of your CPU until you press the key. # #while not keyboard.is_pressed('space'): # continue #print('space was pressed, continuing...') # Do this instead keyboard.wait('space') print('space was pressed, continuing...') ``` ### Repeatedly waiting for a key press ```py import keyboard # Don't do this! # #while True: # if keyboard.is_pressed('space'): # print('space was pressed!') # # This will use 100% of your CPU and print the message many times. # Do this instead while True: keyboard.wait('space') print('space was pressed! Waiting on it again...') # or this keyboard.add_hotkey('space', lambda: print('space was pressed!')) keyboard.wait() ``` ### Invoking code when an event happens ```py import keyboard # Don't do this! This will call `print('space')` immediately then fail when the key is actually pressed. #keyboard.add_hotkey('space', print('space was pressed')) # Do this instead keyboard.add_hotkey('space', lambda: print('space was pressed')) # or this def on_space(): print('space was pressed') keyboard.add_hotkey('space', on_space) # or this while True: # Wait for the next event. event = keyboard.read_event() if event.event_type == keyboard.KEY_DOWN and event.name == 'space': print('space was pressed') ``` ### 'Press any key to continue' ```py # Don't do this! The `keyboard` module is meant for global events, even when your program is not in focus. #import keyboard #print('Press any key to continue...') #keyboard.get_event() # Do this instead input('Press enter to continue...') # Or one of the suggestions from here # https://stackoverflow.com/questions/983354/how-to-make-a-script-wait-for-a-pressed-key ``` )print_functionz0.13.5N)ThreadLock monotoniccCs t|tS)N) isinstance basestring)xr 'C:\Python Projects\keyboard\__init__.pysr cCst|ttfS)N)rintlong)rr r r r s)_EventcCs t|tS)N)rstr)rr r r r scCs t|tS)N)rr )rr r r r s)EventcCst|ttfS)N)rlisttuple)rr r r r sc@seZdZdS)_StateN)__name__ __module__ __qualname__r r r r rs rc@seZdZddZdS)rcCs!xtj|drPqqWdS)Ng?)_UninterruptibleEventwait)selfr r r rsz _Event.waitN)rrrrr r r r rs rWindows) _winkeyboardLinux) _nixkeyboardDarwin)_darwinkeyboardzUnsupported platform '{}')KEY_DOWNKEY_UP KeyboardEvent)GenericListener) all_modifierssided_modifiersnormalize_namecCsMt|r|tkSts?ddtD}tj|n|tkSdS)zI Returns True if `key` is a scan code or name of a modifier key. css|]}t|dVqdS)FN)key_to_scan_codes).0namer r r szis_modifier..N)_is_strr%_modifier_scan_codesupdate)key scan_codesr r r is_modifiers   r1c@seZdZiddedf6ddedf6ddedf6ddedf6ddedf6ddedf6ddedf6ddedf6dded f6dded f6dded f6dded f6dded f6d ded f6d!ded f6d"ded f6d#ded f6d$ded f6d%ded f6d&ded f6d'ded f6d(ded f6d)ded f6d*ded f6Zd d Zd dZddZddZ dS)+_KeyboardListenerFTfreemodifierpendingallowed suppressedNhotkeyothercCstjt|_g|_tjt|_tjt|_ tjt|_ tjt|_ tj |_ d|_i|_dS)NF) _os_keyboardinitsetactive_modifiersblocking_hooks _collections defaultdictr blocking_keysnonblocking_keysblocking_hotkeysnonblocking_hotkeysCounterfiltered_modifiers is_replayingmodifier_states)rr r r r;9s    z_KeyboardListener.initc Csx"|j|jD]}||qWtttt}WdQXx|j|D]}||qRW|jp|jo|jdkS)Nunknown)rB scan_code_pressed_events_lockrsorted_pressed_eventsrDr*)reventkey_hookr8callbackr r r pre_process_eventIsz#_KeyboardListener.pre_process_eventc sn|jr dStfdd|jDs3dSj}j}t|tkrt|rw|jj |nt |.FNr4csg|]}|qSr r )r)rP)rNr r s z5_KeyboardListener.direct_callback..r8r9r3)rGallr> event_typerJrKr!r1r=addrMrrLr"discardrArCrFr<rHgettransition_tablepress_logically_pressed_keysqueueput)rrNrUrJr8rOacceptoriginZmodifiers_to_updateZcallback_resultsr/Ztransition_tupleZ should_pressZ new_acceptZ new_stater )rNr direct_callbackTs^ "                    z!_KeyboardListener.direct_callbackcCstj|jdS)N)r:listenr`)rr r r rasz_KeyboardListener.listen)FTfree)FFzpending)TTrb)FTr6)FFrb)FFr7)FTrb)FTr6)FNrb)FNrb)FNr7)FNr7)FNr7)FNr7)FNr6)FNr6)FTrb)FTrb)TTr6)TTr6)FFr6)TTr6)FTr6)FTr6) rrrr"r!rYr;rQr`rar r r r r2 s:    Gr2Tcszt|r|fSt|r9tdd|DfSt|svtdtt|dt|dnt|}|t krt d|dt d|d}t fd d|DSy5t t j d dtj|D}d }Wn7ttfk rC}zf}|}WYd d }~XnX| rr|rrtd jt||n|Sd S) zT Returns a list of scan codes associated with this key (name or scan code). css|]}t|VqdS)N)r()r)ir r r r+sz$key_to_scan_codes..zUnexpected key type z , value ()zleft Fzright c3s!|]}|kr|VqdS)Nr )r)c)left_scan_codesr r r+scss!|]\}}|dfVqdS)TNr )r)rJr4r r r r+sNz&Key {} is not mapped to any known key.) _is_number_is_listsumr, ValueErrorrtypereprr'r&r(rr? OrderedDictr:map_nameKeyErrorformat)r/Zerror_if_missingZ normalizedZright_scan_codeste exceptionr )rfr r(s(   1  !+  !r(cCst|st|dkr@t|}|f}|f}|St|rttt|stdd|D}|f}|S|Sg}xLtjd|D]8}tjd|}|j tdd|DqWt|S)a Parses a user-provided hotkey into nested tuples representing the parsed structure, with the bottom values being lists of scan codes. Also accepts raw scan codes, which are then wrapped in the required number of nestings. Example: parse_hotkey("alt+shift+a, alt+b, c") # Keys: ^~^ ^~~~^ ^ ^~^ ^ ^ # Steps: ^~~~~~~~~~^ ^~~~^ ^ # ((alt_codes, shift_codes, a_codes), (alt_codes, b_codes), (c_codes,)) rcss|]}t|VqdS)N)r()r)kr r r r+szparse_hotkey..z,\s?z\s?\+\s?css|]}t|VqdS)N)r()r)r/r r r r+s) rglenr(rhanymapr_resplitappend)r8r0stepstepskeysr r r parse_hotkeys      $r~cCsdt_t|}xj|D]b}|rMx"|D]}tj|dq/Wn|rx(t|D]}tj|dq`WqqWdt_dS)a Sends OS events that perform the given *hotkey* hotkey. - `hotkey` can be either a scan code (e.g. 57 for space), single key (e.g. 'space') or multi-key, multi-step hotkey (e.g. 'alt+F4, enter'). - `do_press` if true then press events are sent. Defaults to True. - `do_release` if true then release events are sent. Defaults to True. send(57) send('ctrl+alt+del') send('alt+F4, enter') send('shift+s') Note: keys are released in the opposite order they were pressed. TrFN) _listenerrGr~r:rZreversedrelease)r8Zdo_pressZ do_releaseZparsedr{r0r r r sends    rcCst|dddS)z/ Presses and holds down a hotkey (see `send`). TFN)r)r8r r r rZsrZcCst|dddS)z! Releases a hotkey (see `send`). FTN)r)r8r r r rsrcstjt|r0t|tkSWdQXnt|}t|dkr]tdntttWdQXx5|dD])}t fdd|DsdSqWdS) z Returns True if the key is pressed. is_pressed(57) #-> True is_pressed('space') #-> True is_pressed('ctrl+space') #-> True NrzRImpossible to check if multi-step hotkeys are pressed (`a+b` is ok, `a, b` isn't).rc3s|]}|kVqdS)Nr )r)rJ)pressed_scan_codesr r r+szis_pressed..FT) rstart_if_necessaryrgrKrMr~rurjr<rv)r8r|r0r )rr is_presseds   rgMbP?cs/tdfdd}|jdS)z Calls the provided function in a new thread after waiting some time. Useful for giving the system some time to process an event, without blocking the current execution flow. targetcstjfS)N)_timesleepr )argsdelayfnr r r )szcall_later..N)_Threadstart)rrrthreadr )rrrr call_later#s!rFcCsdS)Nr r r r r r -scsz|r,tjtjjtjj}ntjtj}|fddt.remove_)rrr>rzrZ add_handlerZremove_handlerr)rPsuppressrrzr )rPrrrr rR-s  rRcstfddd|S)zN Invokes `callback` for every KEY_DOWN event. For details see `hook`. cs|jtkp|S)N)rUr")rr)rPr r r Pszon_press..r)rR)rPrr )rPr on_pressLsrcstfddd|S)zL Invokes `callback` for every KEY_UP event. For details see `hook`. cs|jtkp|S)N)rUr!)rr)rPr r r Vszon_release..r)rR)rPrr )rPr on_releaseRsrcstj|rtjntjtxD]}|jq5Wfddt<t.remove_)rrrArBr(rzr)r/rPrrJr )rPr/rr0rr hook_keyXs   rcst|fddd|S)za Invokes `callback` for KEY_DOWN event related to the given key. For details see `hook`. cs|jtkp|S)N)rUr")rr)rPr r r tszon_press_key..r)r)r/rPrr )rPr on_press_keypsrcst|fddd|S)z_ Invokes `callback` for KEY_UP event related to the given key. For details see `hook`. cs|jtkp|S)N)rUr!)rr)rPr r r zsz on_release_key..r)r)r/rPrr )rPr on_release_keyvsrcCst|dS)zc Removes a previously added hook, either by callback or by the return value of `hook`. N)r)rr r r unhook|srcCsOtjtjjtjjtjdd=tjdd=tdS)z{ Removes all keyboard hooks in use, including hotkeys, abbreviations, word listeners, `record`ers and `wait`s. N)rrrAclearrBr>Zhandlersunhook_all_hotkeysr r r r unhook_alls    rcCst|ddddS)zN Suppresses all key events of the given key, regardless of modifiers. cSsdS)NFr )rrr r r r szblock_key..rT)r)r/r r r block_keysrcs%fdd}t||ddS)z Whenever the key `src` is pressed or released, regardless of modifiers, press or release the hotkey `dst` instead. cs*|jtkrtn tdS)NF)rUr!rZr)rN)dstr r handlers  zremap_key..handlerrT)r)srcrrr )rr remap_keysrcs/ddtfddt|DS)z Parses a user-provided hotkey. Differently from `parse_hotkey`, instead of each step being a list of the different scan codes for each key, each step is a list of all possible combinations of those scan codes. cSsddtj|DS)Ncss!|]}tt|VqdS)N)rrL)r)r0r r r r+szBparse_hotkey_combinations..combine_step..) _itertoolsproduct)r{r r r combine_stepsz/parse_hotkey_combinations..combine_stepc3s!|]}t|VqdS)N)r)r)r{)rr r r+sz,parse_hotkey_combinations..)rr~)r8r )rr parse_hotkey_combinationss rcs|rtjntjxPD]H}x.|D]&}t|r,tj|d7.remove)rrCrDr1rFrz)rrrr0rJrr )rrrr _add_hotkey_steps   rcsrfddntjt |r@tntt dkrfdd}t| d fddt<t.rcs@tkr*|jtkr*|jtkp?|jko?S)N)r!rUr"rJr[)rr)rPrUr r r srcs;tjdtjdtjddS)N)_hotkeysrr )rPr8r remove_stepr r rszadd_hotkey..remove_cSsdS)Nr r r r r r sNz-infFcs|jkr.jr.|jjksSrMtjjksS|rjx=jD]2}|jtkrt |jqgt |jqgWjdd=d}dndS)NrT) rUindexrJrr last_updateremove_last_stepsuppressed_eventsr!rZr)rN force_failr)allowed_keys_by_steprU set_indexstatetimeoutr r catch_missess   z add_hotkey..catch_missescs |_|dkr1jdd_n.|dkr_jtdd_n|tdkrfdd}t|jn;jdfd d}t|j_tj_d S) NrcSsdS)Nr r r r r r /sz/add_hotkey..set_index..rrTcso|jtkr#dn|jko8}|rQ|ddS|gjdd.set_index..handlercs7|jtkr#|njj|dS)NF)rUr"rrz)rN new_index)rrrr r rCs  F) rremove_catch_missesrRrurrrrr)rr)rPrrUrrr|r)rr r(s     ! " zadd_hotkey..set_indexcSs"g|]}tj|qSr )r<union)r)r{r r r rSPs zadd_hotkey..csHjjtjdtjdtjddS)N)rrrrr )rPr8rrr r rTs   )rrrr"r!rurrrrrrfloatr)r8rPrrrtrigger_on_releaserr ) rrrPrrUr8rrrrr|rrr add_hotkeys0%     !$%   rcCst|dS)zi Removes a previously hooked hotkey. Must be called with the value returned by `add_hotkey`. N)r)Zhotkey_or_callbackr r r remove_hotkey`srcCstjjtjjdS)zt Removes all keyboard hotkeys in use, including abbreviations, word listeners, `record`ers and `wait`s. N)rrCrrDr r r r rhs rcs+fdd}t||d|d|S)z Whenever the hotkey `src` is pressed, suppress it and send `dst` instead. Example: remap('alt+w', 'ctrl+up') csltddtjjD}x|D]}t|q)Wtxt|D]}t|qTWdS)Ncss'|]\}}|dkr|VqdS)r6Nr )r)r4rr r r r+}sz0remap_hotkey..handler..F)rLrrHitemsrrrrZ)r=r4)rr r r|s"  zremap_hotkey..handlerrr)r)rrrrrr )rr remap_hotkeyss rc Cs;ttt}WdQXx|D]}tj|q W|S)z Builds a list of all currently pressed scan codes, releases them and returns the list. Pairs well with `restore_state` and `restore_modifiers`. N)rKrLrMr:r)rrJr r r stash_states  rc Csdt_ttt}WdQXt|}x||D]}tj|q9Wx||D]}tj|q[Wdt_dS)z Given a list of scan_codes ensures these keys, and only these keys, are pressed. Pairs well with `stash_state`, alternative to `restore_modifiers`. TNF)rrGrKr<rMr:rrZ)r0currentrrJr r r restore_states  rcCstdd|DdS)z@ Like `restore_state`, but only restores modifier keys. css!|]}t|r|VqdS)N)r1)r)rJr r r r+sz$restore_modifiers..N)r)r0r r r restore_modifierssrc Csm|dkr!tjdk}nt}|rx#|D]B}|dkrVt|n tj||r7tj|q7q7Wnx|D]}y1tjt |}t t |\}}Wn+t t tfk rtj|wYnXx|D]} t| qWtj|tj|x|D]} t| q(W|rtj|qqW|rit|ndS)a3 Sends artificial keyboard events to the OS, simulating the typing of a given text. Characters not available on the keyboard are typed as explicit unicode characters using OS-specific functionality, such as alt+codepoint. To ensure text integrity, all currently pressed keys are released before the text is typed, and modifiers are restored afterwards. - `delay` is the number of seconds to wait between keypresses, defaults to no delay. - `restore_state_after` can be used to restore the state of pressed keys after the text is typed, i.e. presses the keys that were released at the beginning. Defaults to True. - `exact` forces typing all characters as explicit unicode (e.g. alt+codepoint or special events). If None, uses platform-specific suggested value. Nrz ) _platformsystemrrr:Z type_unicoderrrnr'nextiterrorj StopIterationrZrr) textrZrestore_state_afterexactrZletterZentriesrJ modifiersr4r r r writes6            rcse|rMtt|fddd|d|}jt|nxtjdqPWdS)zx Blocks the program execution until the given hotkey is pressed or, if given no parameters, blocks forever. cs jS)N)r<r )lockr r r szwait..rrg.AN)rrrrrr)r8rrrr )rr rs '  rc s|dkr?tjtddtjD}WdQXndd|D}tdd|D}ddd d gfd d }d jt|d|S)a Returns a string representation of hotkey from the given key names, or the currently pressed keys if not given. This function: - normalizes names; - removes "left" and "right" prefixes; - replaces the "+" key name with "plus" to avoid ambiguity; - puts modifier keys first, in a standardized order; - sort remaining keys; - finally, joins everything with "+". Example: get_hotkey_name(['+', 'left ctrl', 'shift']) # "ctrl+shift+plus" NcSsg|]}|jqSr )r*)r)rrr r r rSs z#get_hotkey_name..cSsg|]}t|qSr )r')r)r*r r r rSs css9|]/}|jddjddjddVqdS)zleft zright +plusN)replace)r)rrr r r r+sz"get_hotkey_name..ZctrlZaltshiftwindowscs+|krj|ndt|fS)N)rr)rt)rr r r sz!get_hotkey_name..rr/)rrrKrMvaluesr<joinrL)namesZ clean_namesZ sorting_keyr )rr get_hotkey_names  "rcCsItjdd}t|jd|}x|j}t||SWdS)zI Blocks until a keyboard event happens, then returns that event. maxsizerrN)_queueQueuerRr]rXr)rr\hookedrNr r r read_events   rcCst|}|jp|jS)zr Blocks until a keyboard event happens, then returns that event's name or, if missing, its scan code. )rr*rJ)rrNr r r read_keys rc stjfdd}t|d|}xcj}|jtkr3t|t(ddtj D|j g}WdQXt |Sq3WdS)z Similar to `read_key()`, but blocks until the user presses and releases a hotkey (or single key), then returns a string representing the hotkey pressed. Example: read_hotkey() # "ctrl+shift+p" csj|p|jtkS)N)r]rUr!)rr)r\r r r -szread_hotkey..rcSsg|]}|jqSr )r*)r)rrr r r rS4s zread_hotkey..N) rrrRrXrUr"rrKrMrr*r)rrrrNrr )r\r read_hotkey!s   )rccs@tjdkrdnd}d}d}d}x|D]}|j}|jdkr^d}nd|jkr|jd k}q7|jd kr|jd kr| }q7|r|j|kr|jd kr|d d }q7|jd kr7t|d kr%||Ar|j}n||}q3|Vd}q7q7W|Vd S)a Given a sequence of events, tries to deduce what strings were typed. Strings are separated when a non-textual key is pressed (such as tab or enter). Characters are converted to uppercase according to shift and capslock status. If `allow_backspace` is True, backspaces remove the last character typed. This function is a generator, so you can pass an infinite stream of events and convert them to strings in real time. Note this functions is merely an heuristic. Windows for example keeps per- process keyboard state such as keyboard layout, and this information is not available for our hooks. get_type_strings(record()) #-> ['This is what', 'I recorded', ''] rdeleteZ backspaceFrspace rZdownz caps lockNr)rrr*rUruupper)eventsZallow_backspaceZbackspace_nameZ shift_pressedZcapslock_pressedstringrNr*r r r get_typed_strings7s,    $   rcCs+|ptj}|t|jfatS)z Starts recording all keyboard events into a global variable, or the given queue if any. Returns the queue of events and the hooked function. Use `stop_recording()` or `unhook(hooked_function)` to stop. )rrrRr] _recording)recorded_events_queuer r r start_recordingfsrcCs8tstdnt\}}t|t|jS)z] Stops the global recording of events and returns a list of the events captured. z#Must call "start_recording" before.)rrjrrr\)rrr r r stop_recordingrs   rescapecCs$tt|d|d|tS)aH Records all keyboard events from all keyboards until the user presses the given hotkey. Then returns the list of events recorded, of type `keyboard.KeyboardEvent`. Pairs well with `play(events)`. Note: this is a blocking function. Note: for more details on the keyboard hook and events see `hook`. rr)rrr)Zuntilrrr r r record~s rg?cCst}d}x|D]y}|dkrO|dk rOtj|j||n|j}|jpg|j}|jtkrt|n t |qWt |dS)a: Plays a sequence of recorded events, maintaining the relative time intervals. If speed_factor is <= 0 then the actions are replayed as fast as the OS allows. Pairs well with `record()`. Note: the current keyboard state is cleared at the beginning and restored at the end of the function. Nr) rrrtimerJr*rUr!rZrr)rZ speed_factorrZ last_timerNr/r r r plays   )rrcstd_d_fddtfddt<t1) and not in triggers, the characters so far will be discarded. By default the trigger is only `space`. - `match_suffix` defines if endings of words should also be checked instead of only whole words. E.g. if true, typing 'carpet'+space will trigger the listener for 'pet'. Defaults to false, only whole words are checked. - `timeout` is the maximum number of seconds between typed characters before the current word is discarded. Defaults to 2 seconds. Returns the event handler created. To remove a word listener use `remove_word_listener(word)` or `remove_word_listener(handler)`. Note: all actions are performed on key down. Key up events are ignored. Note: word matches are **case sensitive**. rrcs|j}|jtks$|tkr(dSrP|jjkrPd_n|j_jkpojj}|kr|rd_n-t|dkrd_nj|7_dS)Nrr)r*rUr"r%rrendswithru)rNr*Zmatched)rP match_suffixrrtriggerswordr r rs   '  z"add_word_listener..handlercsMtkrt=ntkr3t=ntkrIt=ndS)N)_word_listenersr )rrrrr r rs     z!add_word_listener..remover)rrrrRr)rrPrrrr ) rPrrrrrrrrr add_word_listeners   ! rcCst|dS)z Removes a previously registered word listener. Accepts either the word used during registration (exact string) or the event handler returned by the `add_word_listener` or `add_abbreviation` functions. N)r)Zword_or_handlerr r r remove_word_listenersrcsCdt|d|fdd}t||d|d|S)u Registers a hotkey that replaces one typed text with another. For example add_abbreviation('tm', u'™') Replaces every "tm" followed by a space with a ™ symbol (and no space). The replacement is done by sending backspace events. - `match_suffix` defines if endings of words should also be checked instead of only whole words. E.g. if true, typing 'carpet'+space will trigger the listener for 'pet'. Defaults to false, only whole words are checked. - `timeout` is the maximum number of seconds between typed characters before the current word is discarded. Defaults to 2 seconds. For more details see `add_word_listener`. rcs tS)N)rr ) replacementr r r sz"add_abbreviation..rr)rur)Z source_textZreplacement_textrrrPr )rr add_abbreviationsr)|__doc__ __future__rZ_print_functionversionrerx itertoolsr collectionsr? threadingrrrZ_Lockrrgetattrrr rr,rgrrrr NameErrorr\rrhobjectrplatformrrrrr:rr ImportErrorOSErrorrpZ_keyboard_eventr!r"r#Z_genericr$Z_GenericListenerZ_canonical_namesr%r&r'r<r-r1rKrMZ_physically_pressed_keysr[r2rr(r~rZpress_and_releaserZrrrrrRrrrrrrZ unhook_keyrrZ unblock_keyrZ unremap_keyrrrrZregister_hotkeyrZunregister_hotkeyZ clear_hotkeyrZunregister_all_hotkeysZremove_all_hotkeysZclear_all_hotkeysrZunremap_hotkeyrrrrrrrrrrrrrrrZreplayrrrrZregister_word_listenerZregister_abbreviationZremove_abbreviationr r r r s                   !              7 . ;