def start(self):
self.hotkey = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+<alt>+h'),
self.on_activate)
with keyboard.Listener(on_press=self.for_canonical(self.hotkey.press),
on_release=self.for_canonical(
self.hotkey.release)) as l:
self.l = l
self.client.connect(self.addr)
self.listenerkeyboard = keyboard.Listener(
on_press=self.on_press_key, on_release=self.on_release_key)
self.listenermouse = mouse.Listener(on_move=self.on_move_mouse,
on_click=self.on_click_mouse,
on_scroll=self.on_scroll_mouse)
self.listenerkeyboard.start()
self.listenermouse.start()
self.listenerkeyboard.join()
self.listenermouse.join()
self.l.join()
def get_listener(key, voice):
def on_activate():
print('Global hotkey activated!')
cpstr: str = cp.paste()
print(cpstr)
if cpstr.strip():
cmd = f'say -v {voice} "{cpstr}"'
print(cmd)
os.system(cmd)
pass
def for_canonical(f):
return lambda k: f(listener.canonical(k))
hotkey = keyboard.HotKey(
# keyboard.HotKey.parse('<ctrl>+<alt>+1'),
keyboard.HotKey.parse(key),
on_activate)
with keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(
hotkey.release)) as listener:
listener.join()
return listener
def destroy(self):
"""
Stop if currently recording, reinitiate the main window's hotkey listener, and close this toplevel window
Overrides tkinter.Toplevel.destroy()
:return: None
"""
# Close
if self.recording:
self.new_hotkey_listener.stop()
self.recording = False
# self.root_hotkey_list is either the main window's old hotkey or a new one if one successfully has been
# recorded
keyboard_input = keyboard.HotKey.parse(self.root.get_hotkey_reverse_parse_string(self.root_hotkey_list))
self.root.hotkey = keyboard.HotKey(keyboard_input, self.root.show_screenshot)
self.root.hotkey_listener = keyboard.Listener(on_press=self.root.for_hotkey_canonical(
self.root.hotkey.press),
on_release=self.root.for_hotkey_canonical(
self.root.hotkey.release))
self.root.hotkey_listener.start()
if self.root.image_canvas.text_id != -1:
self.root.image_canvas.draw_text(self.root.get_greeting_text())
super().destroy()
def main(): # pragma: no cover
"""Do main."""
hotkey = keyboard.HotKey(
keyboard.HotKey.parse('<ctrl>+<alt>+g'),
# lambda: on_activate(to_lang="zh"),
# on_activate,
on_trans_hk,
)
hotkey1 = keyboard.HotKey(
keyboard.HotKey.parse('<ctrl>+<alt>+x'),
# lambda: on_activate(to_lang="zh"),
# on_activate1,
on_exit_hk,
)
_ = """
with keyboard.Listener(
on_press=for_canonical(hotkey.press),
on_release=for_canonical(hotkey.release)
) as l:
logger.info(" ready: ctrl-alt-g to activate ")
l.join()
# """
listener = keyboard.Listener(
# on_press=for_canonical(hotkey.press),
# on_release=for_canonical(hotkey.release),
on_press=lambda k: hotkey.press(listener.canonical(k)),
on_release=lambda k: hotkey.release(listener.canonical(k)
), # type: ignore
# on_press=hotkey.press(getattr(listener, "canonical")), # this does not work
)
listener.start()
print("hotkey ctrl-alt-g ...")
ln1 = keyboard.Listener(
# on_press=for_canonical1(hotkey1.press),
# on_release=for_canonical1(hotkey1.release)
on_press=lambda k: hotkey1.press(ln1.canonical(k)),
on_release=lambda k: hotkey1.release(ln1.canonical(k)), # type: ignore
)
ln1.start()
print("hotkey ctrl-alt-x to quit ...")
app.run(read_assist)
def setup_hotkey(gui):
#create the hotkey object, set to win+shift+o
hotkey = keyboard.HotKey(keyboard.HotKey.parse('<cmd>+<shift>+o'),
gui.on_activate)
#from pynput docs, cleans up key modifiers before we pass to the hotkey instance
def for_canonical(f):
return lambda k: f(l.canonical(k))
#create and deploy the keyboard instance
with keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(hotkey.release)) as l:
l.join()
def main():
def write_file(count):
with open("log.txt", "r+") as f:
f.write("Amount of times <ctrl>+l pressed: "+str(count))
f.close()
def on_activate():
logging.info("Ctrl + l pressed")
global count
count += 1
write_file(count)
hotkey = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+l'),on_activate)
def for_canonical(f):
return lambda k: f(l.canonical(k))
with keyboard.Listener(on_press=for_canonical(hotkey.press),on_release=for_canonical(hotkey.release)) as l:
l.join()
def test2():
from pynput import keyboard
def on_press(key):
print(key)
hotkey.press(key)
def on_activate():
print('Global hotkey activated!')
def for_canonical(f):
return lambda k: f(l.canonical(k))
hotkey = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+<alt>+h'),
on_activate)
with keyboard.Listener(on_press=on_press,
on_release=for_canonical(hotkey.release)) as l:
l.join()
hotkey.press(l.canonical())
from pynput import keyboard
from pynput.keyboard import Key, Controller
keyboard2 = Controller()
def on_activate():
#print('Global hotkey activated!')
keyboard2.press('v')
keyboard2.release('v')
keyboard2.press('e')
keyboard2.release('e')
keyboard2.press('l')
keyboard2.release('l')
def for_canonical(f):
return lambda k: f(l.canonical(k))
hotkey = keyboard.HotKey(
#keyboard.HotKey.parse('<ctrl>+<alt>+h'),
#keyboard.HotKey.parse('c'),
keyboard.HotKey.parse('<space>'),
on_activate)
with keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(hotkey.release)) as l:
l.join()
from pynput import keyboard
def on_activate():
print('pasted nerd')
def for_canonical(f):
return lambda k: f(l.canonical(k))
hotkey = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+v'), on_activate)
with keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(hotkey.release)) as l:
l.join()
import clipboard
import atomic_store
from pynput import keyboard
clip_store = atomic_store.open('clipboards.json', default=dict())
def on_activate_paste():
print('pasted')
def on_activate_copy():
clip_store.value["main"] = clip_store.value["main"] + [clipboard.paste()]
def for_canonical(f):
return lambda k: f(l.canonical(k))
paste_hk = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+v'),
on_activate_paste)
copy_hk = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+c'), on_activate_copy)
with keyboard.Listener(on_press=for_canonical(paste_hk.press),
on_release=for_canonical(paste_hk.release)) as l:
l.join()
def record(self, function_name: str):
filename = os.path.join(self.data_path, function_name)
if os.path.isfile(filename):
raise FileExistsError(
'Function "{}" already exists'.format(function_name))
input_hotkey_str = '<ESC>+I'
output_hotkey_str = '<ESC>+O'
print('Starting recording ...')
print('Press {} to put clipboard content into output variable'.format(
output_hotkey_str))
print('Press {} to put input variable into clipboard'.format(
input_hotkey_str))
print('Press <ESC> to stop')
myevents: List[MyInputEvent] = []
input_variables: List[str] = []
output_variables: List[str] = []
stop_event = threading.Event()
input_event = threading.Event()
output_event = threading.Event()
time_delta: float = 0
def on_input():
input_event.set()
stop_event.set()
def on_output():
output_event.set()
stop_event.set()
input_hotkey = keyboard.HotKey(keyboard.HotKey.parse(input_hotkey_str),
on_input)
output_hotkey = keyboard.HotKey(
keyboard.HotKey.parse(output_hotkey_str), on_output)
def on_press(key):
input_hotkey.press(listener.canonical(key))
output_hotkey.press(listener.canonical(key))
myevent = MyInputEvent(KeyPressEvent(key), time_delta=time_delta)
myevents.append(myevent)
def on_release(key):
if key == keyboard.Key.esc:
stop_event.set()
return False
input_hotkey.release(listener.canonical(key))
output_hotkey.release(listener.canonical(key))
myevent = MyInputEvent(KeyReleaseEvent(key), time_delta=time_delta)
myevents.append(myevent)
last_move_myevent = None
def on_mouse_event(event):
nonlocal last_move_myevent
if isinstance(event, mouse.Events.Move):
myevent = MyInputEvent(MoveEvent(x=event.x, y=event.y),
time_delta=time_delta)
if last_move_myevent:
if myevent.timestamp - last_move_myevent.timestamp < 0.1:
return # no need to keep all move events
last_move_myevent = myevent
elif isinstance(event, mouse.Events.Click):
myevent = MyInputEvent(ClickEvent(x=event.x,
y=event.y,
button=event.button,
pressed=event.pressed),
time_delta=time_delta)
elif isinstance(event, mouse.Events.Scroll):
myevent = MyInputEvent(ScrollEvent(x=event.x,
y=event.y,
dx=event.dx,
dy=event.dy),
time_delta=time_delta)
else:
raise RuntimeError(
'Unrecognized mouse event: {}'.format(event))
myevents.append(myevent)
while True:
stop_event.clear()
listener = keyboard.Listener(on_press=on_press,
on_release=on_release)
listener.start()
with mouse.Events() as events:
while True:
if stop_event.is_set():
listener.stop()
break
event = events.get(0.5)
if event is None:
continue
on_mouse_event(event)
if input_event.is_set():
input_event.clear()
t0 = time.time()
name = self.read_variable_name(kind='Input variable name')
if not name:
continue
example_value = self.read_variable_name(
kind='Input example value')
if example_value:
pyperclip.copy(example_value)
deadtime = time.time() - t0
time_delta += deadtime
if name in input_variables:
print('WARNING: input variable "{}" already exists'.format(
name))
else:
input_variables.append(name)
myevent = MyInputEvent(PasteFromVarEvent(name),
time_delta=time_delta)
myevents.append(myevent)
elif output_event.is_set():
output_event.clear()
t0 = time.time()
name = self.read_variable_name(kind='Output variable name')
if not name:
continue
deadtime = time.time() - t0
time_delta += deadtime
if name in output_variables:
print(
'WARNING: output variable "{}" already exists'.format(
name))
else:
output_variables.append(name)
myevent = MyInputEvent(CopyToVarEvent(name),
time_delta=time_delta)
myevents.append(myevent)
else:
break
if myevents:
myfunction = MyFunction(events=myevents,
input_variables=input_variables,
output_variables=output_variables)
self.save(myfunction, filename)
else:
print('WARNING: no input events detected!')
str1 = "/usr/bin/osascript -e \'Tell application \"System Events\" to display dialog \""
str2 = "\" with title \"Hex Converter\"\' &> /dev/null"
return str1 + display_text + str2
def show_dialog(hex_str):
subprocess.run(get_osascript_cmd(hex_str), shell=True)
def on_activate():
sleep(CLIPBOARD_UPDATE_DELAY_SECS) # give clipboard time to update
tokens = tokenize_clipboard()
found_valid_hex = False
for token in tokens:
if hex_prefix in token:
hex_code_str = get_hexcode_string(token)
if is_valid_hex(hex_code_str):
found_valid_hex = True
show_dialog(hex_code_str)
if found_valid_hex:
sanitize_clipboard()
def for_canonical(f):
return lambda k: f(listener.canonical(k))
hotkey = keyboard.HotKey(
keyboard.HotKey.parse('<cmd>+c'),
on_activate)
# Collect events until released
with keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(hotkey.release)) as listener:
listener.join()
from pynput import keyboard
def on_activate():
print("Global hotkey activated!")
def for_canonical(f):
return lambda k: f(l.canonical(k))
hotkey = keyboard.HotKey(keyboard.HotKey.parse("<ctrl>+q"), on_activate)
with keyboard.Listener(
on_press=for_canonical(hotkey.press), on_release=for_canonical(hotkey.release)
) as l:
l.join()
# from pynput import keyboard
# def on_activate_h():
# print('<ctrl>+<alt>+h pressed')
# def on_activate_i():
# print('<ctrl>+<alt>+i pressed')
# with keyboard.GlobalHotKeys({
# '<ctrl>+<alt>+h': on_activate_h,
# '<ctrl>+<alt>+i': on_activate_i}) as h:
# h.join()
def main():
data = subprocess.Popen(['xsel', '-o'], stdout=subprocess.PIPE)
output, err = data.communicate()
output = output.decode("utf-8")
detected_lang = req_post(
f'{detect_lang_url}?key={api_key}&text={parse.quote(output)}&hint=ru;en'
)["lang"]
if detected_lang == "ru":
lang_pair = "ru-en"
elif detected_lang == "en":
lang_pair = "en-ru"
else:
# raise Exception("This is not a ru or eng lang")
lang_pair = "en-ru"
translate = req_post(
f'{translate_url}?key={api_key}&lang={lang_pair}&text={parse.quote(output)}'
)
print(translate)
system(
f'notify-send -a Translater -u normal -t {notify_expire} "{str(translate["text"][0])}"'
)
hotkey = keyboard.HotKey(keyboard.HotKey.parse(hot_key), main)
with keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(hotkey.release)) as l:
l.join()
import keyboard as kb
import time
import pyperclip
import threading
from pynput import keyboard
from app import make_clipboard
from key_listner import for_canonical
from paste_gui import pastingFunction
lst = []
def main():
with keyboard.Listener(on_press=for_canonical(copy.press),
on_release=for_canonical(copy.release)) as l:
l.join()
with keyboard.Listener(on_press=for_canonical(paste.press),
on_release=for_canonical(paste.release)) as thread:
thread.join()
paste = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+v'), pastingFunction)
copy = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+c'), make_clipboard)
def __init__(self, scroll_factor=1.10, hotkey_repr='§', centered_zoom=True, centered_rotation=True,
rotate_nonresponsive_radius_fraction=0.05):
"""
Tkinter window containg a canvas in which an image can be panned, zoomed, and rotated
Functionality:
Pan - Left click and drag
Zoom - Scroll wheel or "+"/"-"-keys
Rotate - Right click and drag
Global screenshot hotkey - Preset to "§" but can be changed in the menu during runtime (se below)
Options menu - M, Alt-, or Menu-key
Fullscreen - F
Reset view - R
Copy image to clipboard - Ctrl+C (If supported by the system)
Paste image from clipboard - Ctrl+V
Open image or PDF - Ctrl+O
Save image - Ctrl+S
:param scroll_factor: float: By how much the bounding box should increase while zooming out. 1.00 represents
no zoom what so ever. 1.10 represents a 10% increase. Zooming out will result in a change of the
boundry box by the factor of the inverse scroll_factor. (default=1.10)
:param centered_zoom: bool: If True, zooms to the center of the ImageCanvas. If False, zoom to the position of
the mouse pointer. (default=True)
:param centered_rotation: bool: If True, rotate around the center of the ImageCanvas. If False, rotate around
the position of the mouse pointer. (default=True)
:param rotate_nonresponsive_radius_fraction: float: Determines the radius around the rotation point where
moving the mouse does not rotate the image. This behaviour is implemented to mitigate the large and sudden
rotations which occur when a short mouse movement corresponds to a large change in rotational angle.
The non-responsive radius is calculated as
radius = min(canvas_width, canvas_height) / 2 * rotate_nonresponsive_radius_fraction,
where 0. < rotate_nonresponsive_radius_fraction < 1. (default=0.05)
"""
super().__init__()
# Settings
# Try to read settings from a settings file
settings_dict = self.read_from_settings_file()
if 'hotkey' in settings_dict:
hotkey_repr = settings_dict['hotkey']
if 'centered_zoom' in settings_dict:
centered_zoom = bool(settings_dict['centered_zoom'])
if 'centered_rotation' in settings_dict:
centered_rotation = bool(settings_dict['centered_rotation'])
if 'geometry' in settings_dict:
geometry = settings_dict['geometry']
else:
geometry = "%dx%d+0+0" % (self.winfo_screenwidth(), self.winfo_screenheight())
# Create the window
self.title("PanZoomRotate")
self.geometry(geometry)
self.fullscreen = False
self.image_canvas = ImageCanvasExtendedFunc(self, pan=True, zoom=True, rotate=True,
scroll_factor=scroll_factor, centered_zoom=centered_zoom,
centered_rotation=centered_rotation,
rotate_nonresponsive_radius_fraction=
rotate_nonresponsive_radius_fraction)
self.image_canvas.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
self.image_canvas.focus_set()
# Hotkey listener
self.hotkey = keyboard.HotKey(keyboard.HotKey.parse(hotkey_repr), self.show_screenshot)
self.hotkey_listener = keyboard.Listener(on_press=self.for_hotkey_canonical(self.hotkey.press),
on_release=self.for_hotkey_canonical(self.hotkey.release))
self.hotkey_listener.start()
# Show initial text
self.image_canvas.draw_text(self.get_greeting_text())
# Set up a menu
self.menu = self.AltMenu(self, centered_zoom=centered_zoom,
centered_rotation=centered_rotation, relief=tk.FLAT)
# Events
self.bind('f', lambda dummy_event: self.set_fullscreen())
self.bind('<Escape>', lambda dummy_event: self.set_fullscreen(state=False))
self.bind("<KeyRelease-Alt_L>", self.show_menu)
self.bind("<KeyRelease-Alt_R>", self.show_menu)
self.bind("m", self.show_menu)
try:
self.bind("<Menu>", self.show_menu)
except tk.TclError:
pass
try:
self.bind("<App>", self.show_menu)
except tk.TclError:
pass
def main(targets, format, target_type, lang, hotkey, paste_key, commit_key,
paste_delay):
words = set()
if target_type == "file":
for t in targets:
with open(t) as f:
tags_done = False
for line in f:
word = line.strip()
if not word:
continue
if word == "---":
tags_done = True
continue
if not tags_done:
continue
words.add(word)
elif target_type == "tag":
targets = set(targets)
for file in os.listdir(lang):
path = os.path.join(lang, file)
with open(path) as f:
tags_selected = False
tags_done = False
for line in f:
word = line.strip()
if not word:
continue
if not tags_done and word in targets:
tags_selected = True
continue
if word == "---":
tags_done = True
continue
if not tags_done:
continue
if not tags_selected:
break
words.add(word)
if format == "comma":
pyperclip.copy(",".join(words))
elif format == "copy_each":
pyperclip.copy("")
word_iter = WordIter(words)
hotkey = keyboard.HotKey(keyboard.HotKey.parse(hotkey), word_iter)
with keyboard.Listener(on_press=hotkey.press,
on_release=hotkey.release) as l:
word_iter.set_listener(l)
l.join()
elif format == "paste_each":
kb = keyboard.Controller()
for word in words:
pyperclip.copy(word)
sleep(paste_delay)
for k in keyboard.HotKey.parse(paste_key):
kb.press(k)
for k in keyboard.HotKey.parse(paste_key):
kb.release(k)
sleep(paste_delay)
for k in keyboard.HotKey.parse(commit_key):
kb.press(k)
for k in keyboard.HotKey.parse(commit_key):
kb.release(k)
sleep(paste_delay)
return 0
只支持一对热键
"""
from pynput import keyboard
def on_activate():
print('Global hotkey activated!')
def for_canonical(f):
return lambda k: f(listener.canonical(k))
hotkey = keyboard.HotKey(
# keyboard.HotKey.parse('<ctrl>+<alt>+1'),
keyboard.HotKey.parse('<ctrl>+1'),
on_activate)
with keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(hotkey.release)) as listener:
listener.join()
def main():
listener.start()
pass
if __name__ == '__main__':
main()
from pynput import keyboard
def on_activate():
print('Global hotkey activated!')
def for_canonical(f):
return lambda k: f(l.canonical(k))
paste = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+v'), on_activate)
copy = keyboard.HotKey(keyboard.HotKey.parse('<ctrl>+c'), on_activate)
with keyboard.Listener(on_press=for_canonical(copy.press),
on_release=for_canonical(copy.release)) as l:
l.join()
def on_modified(self, event):
if os.path.basename(event.src_path) == 'server_log.txt':
with open(event.src_path, 'r') as f:
for line in reversed(f.readlines()):
line = line.strip()
if 'loopback' not in line:
process_line(line)
break
def for_canonical(f):
return lambda k: f(keyboard_listener.canonical(k))
if __name__ == '__main__':
hotkey = keyboard.HotKey(keyboard.HotKey.parse(TOGGLE_KEY), toggle_dzen)
keyboard_listener = keyboard.Listener(on_press=for_canonical(hotkey.press),
on_release=for_canonical(
hotkey.release))
keyboard_listener.start()
observer = Observer()
observer.schedule(MyHandler(), path=SERVER_FILE_PATH, recursive=False)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
keyboard_listener.stop()
observer.join()
