def set_hotkey2(self, event):
event.widget.config(state=NORMAL)
event.widget.delete(0, END)
try:
keyboard.unhook_all_hotkeys()
except:
pass
self.hotkey = keyboard.read_hotkey()
keyboard.stash_state()
keyboard.add_hotkey(self.hotkey, self.capture, args=())
self.write_file()
self.start_frame_label_2['text'] = self.hotkey.upper()
event.widget.delete(0, END)
event.widget.insert(0, self.hotkey.upper())
event.widget.config(state=DISABLED)
self.calculate_width()
def _play(self, speed_factor=7.0, include_clicks=True, include_moves=True, include_wheel=True):
# For hotkey management
state = keyboard.stash_state()
last_time = None
for event in self.events:
if speed_factor > 0 and last_time is not None:
time.sleep((event.time - last_time) / speed_factor)
last_time = event.time
if isinstance(event, KeyboardEvent):
key = event.scan_code or event.name
keyboard.press(key) if event.event_type == KEY_DOWN else keyboard.release(key)
if isinstance(event, ButtonEvent) and include_clicks:
if event.event_type == UP:
mouse.release(event.button)
else:
mouse.press(event.button)
elif isinstance(event, MoveEvent) and include_moves:
mouse.move(event.x, event.y)
elif isinstance(event, WheelEvent) and include_wheel:
mouse.wheel(event.delta)
# For hotkey management
keyboard.restore_modifiers(state)
def play(events,
speed_factor=2,
include_clicks=True,
include_moves=True,
include_wheel=True):
state = key.stash_state()
last_time = None
for event in events:
if speed_factor > 0 and last_time is not None:
time.sleep((event.time - last_time) / speed_factor)
last_time = event.time
# F12 를 누르면 play중 종료
val = key.is_pressed('F12')
if val == True:
key.restore_modifiers(state)
return
if isinstance(event, mo.ButtonEvent) and include_clicks:
if event.event_type == mo.UP:
mo._os_mouse.release(event.button)
else:
mo._os_mouse.press(event.button)
elif isinstance(event, mo.MoveEvent) and include_moves:
mo._os_mouse.move_to(event.x, event.y)
elif isinstance(event, mo.WheelEvent) and include_wheel:
mo._os_mouse.wheel(event.delta)
else:
valkey = event.name
key.press(
valkey) if event.event_type == key.KEY_DOWN else key.release(
valkey)
key.restore_modifiers(state)
def capture_keys(queue):
print("Ctrl-ESC to exit!")
all_keys = np.zeros(128, dtype=np.float32)
running = True
# stash current state
current_state = keyboard.stash_state()
# ctrl-esc
exit_seq = on_sequence([29, 1])
while running:
k = keyboard.read_event(True)
if k.scan_code < len(all_keys) and k.scan_code >= 0:
if k.event_type == "up" and all_keys[k.scan_code] != 0:
all_keys[k.scan_code] = 0.0
if k.event_type == "down" and all_keys[k.scan_code] != 1:
all_keys[k.scan_code] = 1.0
if exit_seq(k.scan_code):
running = False
queue.put((all_keys.tobytes(), k.time, k.name))
keyboard.restore_state(current_state)
time.sleep(0.05)
keyboard.restore_state(current_state)
queue.put(None)
keyboard.restore_state(current_state)
def test_stash_restore_state(self):
self.press("a")
self.press("b")
state = keyboard.stash_state()
self.assertEqual(sorted(self.flush_events()), [(KEY_UP, "a"), (KEY_UP, "b")])
keyboard._pressed_events.clear()
assert len(state) == 2
self.press("c")
keyboard.restore_state(state)
self.assertEqual(sorted(self.flush_events()), [(KEY_DOWN, "a"), (KEY_DOWN, "b"), (KEY_UP, "c")])
def key_tk(*args, **kwargs):
import keyboard
current_state = keyboard.stash_state()
q = Queue()
keys = Process(target=capture_keys, args=(q, ))
keys.start()
k = KeyDisplay(q, *args, **kwargs)
keyboard.restore_state(current_state)
time.sleep(0.5)
keyboard.restore_state(current_state)
return current_state
def test_stash_restore_state(self):
self.press('a')
self.press('b')
state = keyboard.stash_state()
self.assertEqual(sorted(self.flush_events()), [(KEY_UP, 'a'),
(KEY_UP, 'b')])
keyboard._pressed_events.clear()
assert len(state) == 2
self.press('c')
keyboard.restore_state(state)
self.assertEqual(sorted(self.flush_events()), [(KEY_DOWN, 'a'),
(KEY_DOWN, 'b'),
(KEY_UP, 'c')])
def action(self, state: State, player=1):
print('==> %s \t R > S > P' % state)
while True: # making a loop
try: # used try so that if user pressed other than the given key error will not be shown
if keyboard.is_pressed('1'): # if key 'q' is pressed
a = 1
break # finishing the loop
elif keyboard.is_pressed('2'):
a = 2
break
elif keyboard.is_pressed('3'):
a = 3
break
elif keyboard.is_pressed('0'):
a = 0
break
except:
print('1 - Rock, 2 - Scissors, 3 - Paper ')
pass # if user pressed other than the given key the loop will break
keyboard.stash_state() # remove the key press state
return RPSAction(a)
def _thread_play(self,
cv,
events,
speed_factor=1.0,
include_clicks=True,
include_moves=True,
include_wheel=True):
"""
Thread that plays both the mouse and keyboard events back.
This thread will stop the playback if stop_replay == True
"""
last_time = None
state = keyboard.stash_state()
for event_type, event in events:
# Awaken interrupt thread to check for exit status
cv.set()
if self.stop_replay:
return
if speed_factor > 0 and last_time is not None:
time.sleep((event.time - last_time) / speed_factor)
last_time = event.time
if event_type == 'mouse':
if isinstance(event, ButtonEvent) and include_clicks:
if event.event_type == UP:
gui.mouseUp(button=event.button)
else:
gui.mouseDown(button=event.button)
elif isinstance(event, MoveEvent) and include_moves:
mouse.move(event.x, event.y)
elif isinstance(event, WheelEvent) and include_wheel:
mouse.wheel(event.delta)
elif event_type == 'keyboard':
key = event.name or event.scan_code
keyboard.press(
key) if event.event_type == KEY_DOWN else keyboard.release(
key)
else:
raise Exception("Incorrect type of event")
keyboard.restore_modifiers(state)
def read_hotkey():
t = keyboard.stash_state()
s = keyboard.read_hotkey()
keyboard.restore_state(t)
return s
# draw the blank squares for the outputs
if self.use_rwo:
src.canvas.itemconfig(self.text, text=str(self.rwo.n_vecs))
self.matrix_display.update(self.state)
def key_tk(*args, **kwargs):
import keyboard
current_state = keyboard.stash_state()
q = Queue()
keys = Process(target=capture_keys, args=(q, ))
keys.start()
k = KeyDisplay(q, *args, **kwargs)
keyboard.restore_state(current_state)
time.sleep(0.5)
keyboard.restore_state(current_state)
return current_state
if __name__ == "__main__":
import keyboard, atexit
current_state = keyboard.stash_state()
atexit.register(keyboard.restore_state, current_state)
q = Queue()
keys = Process(target=capture_keys, args=(q, ))
keys.start()
k = KeyDisplay(q)
mainloop()
def test_stash_state(self):
self.do(d_a + d_shift)
self.assertEqual(sorted(keyboard.stash_state()), [1, 5])
self.do([], u_a + u_shift)
def test_stash_state(self):
self.do(d_a+d_shift)
self.assertEqual(sorted(keyboard.stash_state()), [1, 5])
self.do([], u_a+u_shift)
def capHotkey():
keyboard.stash_state() # This ensures no key sticking and is stupid
save = keyboard.stash_state() # Save the keyboard state prior to hotkey intake
hotkey = keyboard.read_hotkey() # Read the hotkey
keyboard.restore_state(save) # Restore the keyboard state after hotkey intake
return hotkey
import keyboard
import ctypes
print("Press your hotkey: ")
hotkey = keyboard.read_hotkey()
keyboard.stash_state()
print("Hotkey registered: " + hotkey)
while True:
keyboard.wait(hotkey)
ctypes.windll.user32.BlockInput(True)
keyboard.wait(hotkey)
ctypes.windll.user32.BlockInput(False)
def doNothing(self, e):
print("keyboard hooked")
keyboard.stash_state()
def _on_unlock(self):
self.logger('UNLOCKED')
keyboard.stash_state()
def _rehook(self):
while True:
time.sleep(self.config.hook_refresh_interval)
keyboard.stash_state()