i:JSrSSKJr SrSSKrSSKrSSK r SSK J r Jr SSKr\"\SS5=(d \R \l\\4 SrSrSSKrSS K Jr S r"SS\ 5r!"SS\5rSSK"r#\#RH"5S:XaSSK%J&r' O^\#RH"5S:XaSSK%J(r' OB\#RH"5S:XaSSK%J)r' O&\*"SRW\#RH"555eSSK,J-r-J.r.J/r/ SSK0J1r2 SSK3J4r4J5r5J6r6 \7"5r8Sr9\"5r:0r;\;r<0r="SS\25r>\>"5r?SLS jr@S!rASMS"jrB\BrCS#rDS$rES%rFSNS&jrG0rHS'S(4S)jrISOS*jrJSOS+jrKSOS,jrLSOS-jrMSOS.jrNS/rO\OrPS0rQS1rR\PrSS2rT\PrUS3rVS4rW0rXSPS5jrY\YrZS6r[\[=r\r]S7r^\^=r_=r`raSQS8jrb\[rcS9rdS:reS;rfSRS<jrgSSS=jrhSTS>jriSOS?jrjSOS@jrkSLSAjrlSLSBjrmSqnSTSCjroSDrpSUSEjrqSVSFjrr\rrs0rtSG/S'SH4SIjruSJrvSWSKjrw\urx\wry\vrzg!\a S rS rSSKrSS K Jr GNf=f)XuK 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 ```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() ``` ## 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. )print_functionz0.13.5N)ThreadLock monotonicc"[U[5$N) isinstance basestringxs U/home/kali/github-search/github-env/lib/python3.13/site-packages/keyboard/__init__.pyr_s 1j1c.[U[[45$r)r intlongr s r rr`s:a#t5r)_Eventc"[U[5$r)r strr s r rrfs 1c*rc"[U[5$r)r rr s r rrgs :a-r)Eventc.[U[[45$r)r listtupler s r rrjsZD%=1rc\rSrSrSrg)_StatemN)__name__ __module__ __qualname____firstlineno____static_attributes__rrr rrmsdrrc\rSrSrSrSrg)rrcB[R"US5(agM)Ng?)_UninterruptibleEventwaitselfs r r( _Event.waitss $))$44rrN)rr r!r"r(r#rrr rrrsrrWindows) _winkeyboardLinux) _nixkeyboardDarwin)_darwinkeyboardzUnsupported platform '{}')KEY_DOWNKEY_UP KeyboardEvent)GenericListener) all_modifierssided_modifiersnormalize_namec[U5(a U[;$[(d S[5n[R"U6 U[;$)zA Returns True if `key` is a scan code or name of a modifier key. c3:# UHn[US5v M g7f)FNkey_to_scan_codes).0names r is_modifier..sS]T+D%88]s)_is_strr7_modifier_scan_codesupdate)key scan_codess r is_modifierrGsBs||m####S]SJ ' ' 4***rcF\rSrSr0S\S4S_S\S4S_S\S4S_S\S4S_S \S4S _S \S4S _S \S4S_S \S4S_S\S 4S_S\S 4S_S\S 4S_S\S 4S_S \S 4S_S \S 4S_S \S 4S_S \S 4S_S\S4S_S\S4SS\S4SS\S4SS \S4SS \S4SS \S4SS \S4S0ErSrSrSr Sr Sr g)_KeyboardListenerfreemodifier)FTrK)FFpendingrM)TTrK)FTallowed suppressed)FFrK)FFrOrNhotkey)FNrK)FNrO)FNrNother)TTrN)FFrNc[R"5 [5Ul/Ul[ R "[5Ul[ R "[5Ul [ R "[5Ul [ R "[5Ul [ R"5Ul SUl0UlgNF) _os_keyboardinitsetactive_modifiersblocking_hooks _collections defaultdictr blocking_keysnonblocking_keysblocking_hotkeysnonblocking_hotkeysCounterfiltered_modifiers is_replayingmodifier_statesr)s r rU_KeyboardListener.inits # )55d; , 8 8 > , 8 8 >#/#;#;D#A "."6"6"8! "rchURURH nU"U5 M [ [[ [ 55nSSS5 UR WH nU"U5 M UR=(d" UR=(a URS:g$!,(df  Na=f)Nunknown)r\ scan_code_pressed_events_lockrsorted_pressed_eventsr^r?)r*eventkey_hookrPcallbacks r pre_process_event#_KeyboardListener.pre_process_events--eoo>H UO?"6/23F"008H UO9J5::#I%** 2IJ " !s B## B1c^UR(ag[U4SjUR55(dgTRnTRn[  U[ :Xa4[U5(aURRU5 T[U'[[[55nU[:Xa,URRU5 U[;a[U SSS5 URUHnU"T5(aM g SnUR (aUR"U(aSn[%U/5nO\URn[U5(aX1-nUR WV s/sH o"T5PM n n U (a[U 5nSnOSn[U5HXn UR&R)U S5X'4n UR*U upnU (a [-U 5 UbUnXR&U 'MZ U(a/U[ :Xa T[.U'OU[:XaU[.;a[.U UR0R3T5 U$!,(df  GN=fs sn f) aK This function is called for every OS keyboard event and decides if the event should be blocked or not, and passes a copy of the event to other, non-blocking, listeners. There are two ways to block events: remapped keys, which translate events by suppressing and re-emitting; and blocked hotkeys, which suppress specific hotkeys. Tc32># UH o"T5v M g7frr)r>hookrjs r r@4_KeyboardListener.direct_callback..s?+>44;;+>sFNrLrPrQrK)raallrX event_typerfrgr3rGrWaddrirrhr4discardr[r]r`rVrbgettransition_tablepress_logically_pressed_keysqueueput)r*rjrtrfrPrkacceptoriginmodifiers_to_updaterlcallback_resultsrEtransition_tuple should_press new_accept new_states ` r direct_callback!_KeyboardListener.direct_callbacks"   ?4+>+>???%% OO "X%y))4+@+@+D+DY+O-2 *6/23FV#%%--i8/_Y5O"**95HE??6   &&y1#&)9+&6#&*&;&;#y))*= *K'DHDYDYZ`Da#bDaHUODa #b# !12F%F$F12$($8$8$<$ v).D?)@ x).D v).G x).G v).G x).G v).G x).GQ)V" KEN2rrIc^[U5(aU4$[U5(a[SU5S5$[U5(d2[ S[ [ U55-S-[U5-S-5e[U5nU[;a6[SU-S5m[SU-S5nT[U4S jU55-$[[R"S [R"U5555nS nU(d+U(a$[ S R#[U55U5eU$![ [4anSnUnS nANMS nAff=f) zL Returns a list of scan codes associated with this key (name or scan code). c38# UHn[U5v M g7frr<)r>is r r@$key_to_scan_codes..1s6#Q%a((#rzUnexpected key type z , value ()left Fright c36># UHoT;dM Uv M g7frr)r>cleft_scan_codess r r@r9s&_2BQF^qq2Bs  c3.# UH upUS4v M g7f)TNr)r>rfrLs r r@r=s*zXyATIt+ks r r@parse_hotkey..^s>v!*1--vrz,\s?z\s?\+\s?c38# UHn[U5v M g7frr<)r>rEs r r@rfsBTc,S11Tr) rlenr=ranymapr_resplitappend)rPrFstepstepskeyss r parse_hotkeyrHs&S[A-&v. } &  3x())>v>>DGEL E '6*yyd+ UBTBBC+ <rcS[l[U5nUH`nU(a"UHn[R"US5 M U(dM5[ U5Hn[R "US5 M Mb S[lg)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) _listenerrarrTryreversedrelease)rPdo_press do_releaseparsedrrFs r sendrisp "I & !F " "":a=1# :&tn $$Z]3- #Irc[USS5 g)z.Presses and holds down a hotkey (see `send`). TFNrrPs r ryrysurc[USS5 g)z Releases a hotkey (see `send`). FTNrrs r rrsrc^[R5 [U5(a[ U[;sSSS5 $[ U5n[ U5S:a [S5e[ [[5mSSS5 USHn[U4SjU55(aM g g!,(df  Nz=f!,(df  NH=f)z Returns True if the key is pressed. is_pressed(57) #-> True is_pressed('space') #-> True is_pressed('ctrl+space') #-> True Nr-zRImpossible to check if multi-step hotkeys are pressed (`a+b` is ok, `a, b` isn't).rc3,># UH oT;v M g7frr)r>rfpressed_scan_codess r r@is_pressed..sOJy 22JsFT) rstart_if_necessaryrrgrirrrrVr)rPrrFrs @r is_pressedrs  "& !_," !  E 5zA~mnn  1 Ah OJOOO " !  s B+*B<+ B9< C cH^^^[UUU4SjS9nUR5 g)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. c:>[R"T5T"T64$r)_timesleep)argsdelayfnsr rcall_later..sU[[%7T$Cr)targetN)_Threadstart)rrrthreads``` r call_laterrs C DF LLNrFcgrrrrr rrsTrc8^^^^U(aJ[R5 [RR[RRsnmO![R [R snmU"T5 UUUU4SjmT=[T'[T'T$)a+ Installs a global listener on all available keyboards, invoking `callback` each time a key is pressed or released. The event passed to the callback is of type `keyboard.KeyboardEvent`, with the following attributes: - `name`: an Unicode representation of the character (e.g. "&") or description (e.g. "space"). The name is always lower-case. - `scan_code`: number representing the physical key, e.g. 55. - `time`: timestamp of the time the event occurred, with as much precision as given by the OS. Returns the given callback for easier development. c@>[T [T T"T5 T"5 gr_hooks)rl on_removeremoveremove_sr rhook..remove_s 8  7Ox r)rrrXrr add_handlerremove_handlerr)rlsuppressrrrrs` ` @@r rqrqsz $$&"1188):R:R:Y:Y".. 0H0H 8 *10F8vg Nrc ^[U4SjUS9$)zF Invokes `callback` for every KEY_DOWN event. For details see `hook`. cH>UR[:H=(d T"U5$rrtr4rrls r ron_press..s!,,&0?HQK?rrrqrlrs` r on_pressrs ?( SSrc ^[U4SjUS9$)zD Invokes `callback` for every KEY_UP event. For details see `hook`. cH>UR[:H=(d T"U5$rrtr3rs r ron_release..s!,,(2AhqkArrrrs` r on_releasers AH UUrc ^^^^^[R5 U(a[RO[Rm[ T5mTHnTUR T5 M UUUUU4SjmT=[ T'=[ T'[ T'T$)z Hooks key up and key down events for a single key. Returns the event handler created. To remove a hooked key use `unhook_key(key)` or `unhook_key(handler)`. Note: this function shares state with hotkeys, so `clear_all_hotkeys` affects it as well. cj>[T [T [T THnTURT5 M gr)rr)rfrlrErrFstores r rhook_key..remove_s6 8  3K 7O#I )  # #H -$r)rrr[r\r=rr)rErlrrfrrFrs`` @@@r hook_keyrsz  "'/I # #Y5O5OE"3'J  i) .. 8?>F8>vc{VG_ Nrc"^[UU4SjUS9$)zY Invokes `callback` for KEY_DOWN event related to the given key. For details see `hook`. cH>UR[:H=(d T"U5$rrrs r ron_press_key..s1<<6#9#HXa[#HrrrrErlrs ` r on_press_keyrs CHS[ \\rc"^[UU4SjUS9$)zW Invokes `callback` for KEY_UP event related to the given key. For details see `hook`. cH>UR[:H=(d T"U5$rrrs r r on_release_key..s1<<8#;#Jx{#Jrrrrs ` r on_release_keyrs CJU] ^^rc [U"5 g)zW Removes a previously added hook, either by callback or by the return value of `hook`. Nr)rs r unhookrs  6Nrc[R5 [RR5 [RR5 [R SS2 [R SS2 [5 g)zo Removes all keyboard hooks in use, including hotkeys, abbreviations, word listeners, `record`ers and `wait`s. N)rrr[clearr\rXhandlersunhook_all_hotkeysrrr unhook_allrsV   " !!# $$&  #1rc[USSS9$)zF Suppresses all key events of the given key, regardless of modifiers. cgrSr)rs r rblock_key..s5rTrrrEs r block_keyrs C4 88rc$^U4Sjn[XSS9$)zt Whenever the key `src` is pressed or released, regardless of modifiers, press or release the hotkey `dst` instead. c\>UR[:Xa [T5 g[T5 grS)rtr3ryr)rjdsts r handlerremap_key..handler&s)   x ' #J CLrTrr)srcr r s ` r remap_keyr!s  C4 00rcF^Sm[U4Sj[U555$)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. c6S[R"U65$)Nc3J# UHn[[U55v M g7fr)rrh)r>rFs r r@Bparse_hotkey_combinations..combine_step..;sV.combine_step5s WJ# UHn[T"U55v M g7fr)r)r>rrs r r@,parse_hotkey_combinations..=s L7Kt|D)**7Ks!)rr)rPrs @r parse_hotkey_combinationsr/s! W L|F7KL LLrc^^^U(a[RO[RmTHMnUH0n[U5(dM[RU==S- ss'M2 TUR T5 MO UUU4SjnU$)z. Hooks a single-step hotkey (e.g. 'shift+a'). r-c>THMnUH0n[U5(dM[RU==S-ss'M2 TURT5 MO g)Nr-)rGrr`r)rFrf combinations containerr s r r _add_hotkey_step..removeNsM&J' y))00;q@;( j ! ( ( 1 'r)rr]r^rGr`r)r rrrFrfrrs`` @r _add_hotkey_stepr ?sr/7 **IU"T6$rr)rlrs r radd_hotkey..}s Xt_rr-c>T[:H=(a- UR[:H=(a UR[;=(d TUR:H=(a T"5$r)r3rtr4rfrz)rrlrts r rr#snZ83y 8NySTS^S^bySyj@JNONZNZ@Z@i_g_ijrrc>>T"5 [T [T [T gr_hotkeys)rlrPr remove_stepsr radd_hotkey..remove_s M !"rNz-infc>URT:Xa.TR(aURTTR;d4T(a&[R"5TR - T:dU(a|TR 5 TRHCnUR[:Xa[UR5 M.[UR5 ME TRSS2 SnT"S5 g)NrT) rtindexrfrr last_updateremove_last_stepsuppressed_eventsr3ryr)rj force_failr+allowed_keys_by_steprt set_indexstatetimeouts r catch_misses add_hotkey..catch_missess  J.KKOO+? +LLOO%(9(99WD  " " $00##x/%//*EOO, 1 ''*E aLrc>^UTlUS:Xa STlO%US:XaTR5 [TSS9TlU[T5S- :Xa&UUUUUU4Sjn[ UTTRT 5mO2TRS-4UUU4Sjjn[ UTTRT 5mTTl[ R"5Tlg) Nrcgrrrrr r/add_hotkey..set_index..srr-Trc>UR[:XaT"5 T"S5 URT:H=(a T"5nU(aT"USS9$U/TRSS&g)NrT)r/F)rtr4r.)rjr}rlr4rtrr1r2s r r .add_hotkey..set_index..handlersY##v-HaL))Z7FHJ'$??27E++A. rc>UR[:XaT"5 T"U5 TRRU5 grS)rtr4r.r)rj new_indexrr1r2s r r r:s5##v-Hi(''..u5rF) r+remove_catch_missesrqrr r-rrr,) r<r rrlr4rtr1r2rrs @r r1add_hotkey..set_indexs >)5E % !^  % % '(,\D(IE % E Q & ! !&guU[[/A8LF*/Q   &guU[[/A8LF!'!OO-rcp>TR5 TR5 [T [T [T gr)r=r-r')rlrPrr2sr rr)s3 !!#  V  W  X rF)rrrr4r3rr r'rr=r-r.floatr,rVunion)rPrlrrr3trigger_on_releaser rr0r4rtrr(r1r2rs````` @@@@@@@@r add_hotkeyrDWs1J #+<   " %f -E-8J 5zQ j&wa(C  # #ELKK8G,x/A HE $E!E Ef E.##HaLD  T AHGHVGx(8H+= Ns/!D9c [U"5 g)z] Removes a previously hooked hotkey. Must be called with the value returned by `add_hotkey`. Nr&)hotkey_or_callbacks r remove_hotkeyrGs   "rc|[RR5 [RR5 g)zh Removes all keyboard hotkeys in use, including abbreviations, word listeners, `record`ers and `wait`s. N)rr]rr^rrr rrs($$& !!'')rc$^U4Sjn[XX#S9$)zt Whenever the hotkey `src` is pressed, suppress it and send `dst` instead. Example: remap('alt+w', 'ctrl+up') c>[S[RR555nUHn[ U5 M [ T5 [ U5Hn[U5 M g)Nc3:# UHupUS:XdM Uv M g7f)rNNr)r>rLr2s r r@0remap_hotkey..handler..s!zBcxglpygy((Bcs  F)rhrrbitemsrrrry)rWrLr s r r remap_hotkey..handlersV!!z)B[B[BaBaBc!zz(H H ) S  !12H (O3rrrC)rD)rr rrCr s ` r remap_hotkeyrPs cX ]]rc[ [[5nSSS5 WHn[R"U5 M U$!,(df  N/=f)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)rgrhrirTr)r2rfs r stash_staterRs< '  Y' L  s A Ac*S[l[ [[5nSSS5 [U5nWU- Hn[ R "U5 M X!- Hn[ R"U5 M S[lg!,(df  Nh=f)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)rrargrVrirTrry)rFcurrentrrfs r restore_staterUsr "I o&  _Fv% Y'&% 9%&#I  s B Bc([SU55 g)z8 Like `restore_state`, but only restores modifier keys. c3J# UHn[U5(dMUv M g7fr)rG)r>rfs r r@$restore_modifiers..1sSjK TR5$r)rV)locksr rwait..qs DHHJrrOg.AN)rrDr(rGrr)rPrrCrris @r r(r(jsC xF$6q f KK rc^UcQ[R5 [ [R 5Vs/sHoR PM nnSSS5 OUVs/sHn[ U5PM nn[SU55n/SQmU4SjnSR[X4S95$s snf!,(df  NG=fs snf)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" Nc3# UH6oRSS5RSS5RSS5v M8 g7f)rr+plusN)replace)r>rs r r@"get_hotkey_name..s:gaf\]ii,44XrBJJ3PVWWafs>A)ctrlaltshiftwindowscL>UT;aTRU5OS[U54$)N)r+r)rres r r!get_hotkey_name..s1 >Y__Q/q#a&Qrrnr) rrrgrivaluesr?r9rVjoinrh)namesrr? clean_names sorting_keyres @r get_hotkey_namer~xs" }$$& !%4%;%;%=>%=VV%=E>" !388%$%%8gafggK4IQK 88F;8 99?" !9s"B*B% B*B;%B** B8c[R"SS9n[URUS9nUR 5n[ U5 U$)zA Blocks until a keyboard event happens, then returns that event. r-)maxsizer)_queueQueuerqr|rwr)rr{hookedrjs r read_eventrs< LL #E %))h /F  v rcV[U5nUR=(d UR$)zf Blocks until a keyboard event happens, then returns that event's name or, if missing, its scan code. )rr?rf)rrjs r read_keyrs! x E :: ((rc^[R"5mU4Sjn[XS9nTR5nUR[ :Xaa[ U5 [ [R5Vs/sHoDRPM snUR/-nSSS5 [W5$Ms snf!,(df  N =f)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" cZ>TRU5=(d UR[:H$r)r|rtr3)rr{s r rread_hotkey..s599Q<;1<<8#;;rrN) rrrqrwrtr4rrgriryr?r~)rrrrjrr{r{s @r read_hotkeyrs LLNE ;B " (F     v % 6N%)8)?)?)AB)AA)ABejj\Q&"5) )  C&%sB33B.B3.B33 Cc#$# [R"5S:XaSOSnSnSnSnUHnURnURS:XaSnSUR;aURS :HnMBURS :XaURS :Xa U(+nMkU(a'URU:XaURS :XaUS S nMURS :XdM[ U5S :XaX4- (aUR 5nXW-nMUv SnM Uv g 7f)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', ''] r1delete backspaceFrmspace rtdownz caps lockNr-)r[r\r?rtrupper)eventsallow_backspacebackspace_name shift_pressedcapslock_pressedstringrjr?s r get_typed_stringsrs""+!1!1!3x!?X[NM Fzz :: D ejj !,,6M ZZ; &5+;+;v+E#33  ~!=%BRBRV\B\CR[F    '4yA~ 3::??$.! 6N %++ ,,rc>[5 [XUS9 [5$)a, 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`. rO)rr(r)untilrrCs r recordrs6HI  rcP[5nSnUHnUS:a)Ub&[R"URU- U- 5 URnUR=(d UR nUR [:Xa [U5 M~[U5 M [U5 g)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) rRrrtimerfr?rtr3ryrrY)r speed_factorr2 last_timerjrEs r playrs MEI !  5 KKi/<? @JJ oo+&&(2c  errc^^^^^^^^^[5mSTlSTlUUUUUU4Sjm[T5mUUUU4SjmT=[T'=[T'[T'T$)ar Invokes a callback every time a sequence of characters is typed (e.g. 'pet') and followed by a trigger key (e.g. space). Modifiers (e.g. alt, ctrl, shift) are ignored. - `word` the typed text to be matched. E.g. 'pet'. - `callback` is an argument-less function to be invoked each time the word is typed. - `triggers` is the list of keys that will cause a match to be checked. If the user presses some key that is not a character (len>1) 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**. rmrc>URnUR[:Xd U[;agT(a$URTR- T:aSTlURTlTR T:H=(d$ T=(a TR R T5nUT;aU(aT"5 STlg[U5S:aSTlgT=R U- slg)Nrmr-)r?rtr4r7rrTendswithr) rjr?matchedrl match_suffixr2r3triggerswords r r "add_word_listener..handlerJszz   v %)> uzzEJJ.8EMZZ --4'ZL,YU]]=S=STX=Y 8  JEM Y]EM MMT !Mrc>>T"5 [T [T [T gr_word_listeners)r rrrsr r!add_word_listener..remove\s  D ! G $ F #r)rrTrrqr) rrlrrr3r rrr2s `````@@@@r add_word_listenerr-sa2 HEEMEJ"""']F$$ RXWODWOG4v7N Mrc [U"5 g)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. Nr)word_or_handlers r remove_word_listenerres O$&rcL^S[U5S--U-mU4Sjn[XX#S9$)uy 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`. r-c>[T5$r)rf) replacementsr r"add_abbreviation..s u[)r)rr3)rr) source_textreplacement_textrr3rlrs @r add_abbreviationrms1"K(*+.>>K)H [ __r)T)TT)rgMbP?r@)rFr-F)TF)rTN)NFFr)escapeFF)g?)Fr){__doc__ __future__r_print_functionversionrer itertoolsr collectionsrY threadingrrr_Lockrrgetattrrrr rBrrrrr' NameErrorr{rrobjectrplatformr[r\rmr.rTr0r2OSErrorr_keyboard_eventr3r4r5_genericr6_GenericListener_canonical_namesr7r8r9rVrCrGrgri_physically_pressed_keysrzrIrr=rrpress_and_releaseryrrrrrqrrrrrr unhook_keyrr unblock_keyr unremap_keyrr r'rDregister_hotkeyrGunregister_hotkey clear_hotkeyrunregister_all_hotkeysremove_all_hotkeysclear_all_hotkeysrPunremap_hotkeyrRrUrYrfr(r~rrrrrrrrrreplayrrrrregister_word_listenerregister_abbreviationremove_abbreviationrrr rsM\9 "6%d3Auzz 9*1G5J9 2V  "  "-7"-8#0 -44Y5E5E5GH II<<9LLu +w*O2(O2b   <B#>6 !\>T V 0] _    9   1 M . O`# $10L*CUTT+.?^$ #"U 5!n :> )*,,\   - * 07yuVW6p'`,+(*C!9*G-J88 9sHH"!H"