Как на python блокировать клавиатуру

Мониторинг и управление клавиатурой в Python

Использование модуля pynput.keyboard библиотеки pynput в Python

Модуль pynput.keyboard библиотеки pynput содержит классы для управления и мониторинга клавиатуры.

Содержание:

• Управление клавиатурой;
• Мониторинг клавиатуры;
• Поток слушателя клавиатуры Listener ;
• Обработка ошибок слушателя клавиатуры;
• Переключение прослушивания событий для клавиатуры;
• Синхронное прослушивание событий для клавиатуры;
• Прослушивание глобальных горячих клавиш;

Управление клавиатурой.

Для управления клавиатурой используйте класс keyboard.Controller следующим образом:

from pynput.keyboard import Key, Controller keyboard = Controller() # Нажимает и отпускает клавишу пробела keyboard.press(Key.space) keyboard.release(Key.space) # печатает строчную букву `a`, будет работать, даже если ни # одна клавиша на физической клавиатуре не помечена буквой `a`. keyboard.press('a') keyboard.release('a') # печатает две заглавные буквы `A`: # выводим сразу заглавную 'A' keyboard.press('A') keyboard.release('A') # выводим заглавную 'A' через нажатие `Key.shift` with keyboard.pressed(Key.shift): keyboard.press('a') keyboard.release('a') # печатает 'Hello World', используя метод быстрого ввода keyboard.type('Hello World') 

Мониторинг клавиатуры.

Для мониторинга клавиатуры используйте класс keyboard.Listener следующим образом:

from pynput import keyboard def on_press(key): try: print(f'Нажата буквенно-цифровая клавиша: key.char>') except AttributeError: print(f'Нажата специальная клавиша: key>') def on_release(key): print(f'key> released') if key == keyboard.Key.esc: # Возврат False - остановит слушатель return False # блок `with` слушает события до выхода # до остановки слушателя with keyboard.Listener( on_press=on_press, on_release=on_release) as listener: listener.join() #. или неблокирующим способом: listener = keyboard.Listener( on_press=on_press, on_release=on_release) listener.start() 

Слушатель клавиатуры keyboard.Listener — это threading.Thread , и все обратные вызовы будут вызываться из потока.

Чтобы остановить слушатель клавиатуры, можно вызвать keyboard.Listener.stop() из любого места, что в свою очередь вызовет исключение StopException или возвратить False из функции обратного вызова.

Аргумент key , который передается слушателем в обратные вызовы, является keyboard.Key для специальных клавиш и keyboard.KeyCode для обычных буквенно-цифровых клавиш или просто None для неизвестных клавиш.

При использовании приведенной выше неблокирующей версии текущий поток продолжит выполнение. Это может быть необходимо при интеграции с другими платформами графического интерфейса, включающими основной цикл, но при запуске из скрипта это приведет к немедленному завершению программы.

Поток слушателя клавиатуры keyboard.Listener .

Обратные вызовы слушателя keyboard.Listener , на некоторых платформах, особенно в Windows, вызываются непосредственно из рабочего потока. Это означает, что длительно выполняющиеся процедуры и блокирующие операции не должны вызываться из обратного вызова, так как это может привести к зависанию ввода для всех процессов.

Возможный обходной путь — это просто отправить входящие события в очередь и позволить отдельному потоку обрабатывать их.

Обработка ошибок слушателя клавиатуры.

Если обработчик обратного вызова вызывает исключение, то слушатель будет остановлен. Поскольку обратные вызовы выполняются в выделенном потоке, исключения не будут автоматически повторно вызываться.

Чтобы получать уведомления об ошибках обратного вызова, необходимо вызвать Thread.join() для экземпляра слушателя keyboard.Listener :

from pynput import keyboard class MyException(Exception): pass def on_press(key): if key == keyboard.Key.esc: raise MyException(key) # блок `with` слушает события до выхода with keyboard.Listener( on_press=on_press) as listener: try: listener.join() except MyException as e: print(f'e.args[0]>') 

Переключение прослушивания событий для клавиатуры.

После вызова keyboard.Listener.stop() слушатель не может быть перезапущен, так как слушатели keyboard.Listener являются экземплярами threading.Thread .

Если приложение требует переключения событий keyboard.Listener , то необходимо либо добавить внутренний флаг для игнорирования событий, когда они не требуются, либо создать новый слушатель keyboard.Listener для возобновления прослушивания.

Синхронное прослушивание событий для клавиатуры.

Для упрощения написания сценариев с синхронным прослушиванием событий поддерживается служебный класс keyboard.Events . Этот класс поддерживает чтение отдельных событий неблокирующим способом, а также повторение всех событий.

Чтобы прочитать одно событие, используйте следующий код:

from pynput import keyboard # В блоке `with` будет работать слушатель событий. with keyboard.Events() as events: # Блокировать не более одной секунды event = events.get(1.0) if event is None: print('Вы не нажали клавишу в течение одной секунды') else: print('Получено событие ') 

Чтобы перебрать события клавиатуры, используйте следующий код:

from pynput import keyboard # В блоке `with` будет работать слушатель событий. with keyboard.Events() as events: for event in events: if event.key == keyboard.Key.esc: # выход из слушателя break else: print('Получено событие ') 

Обратите внимание, что контекстный менеджер with не поддерживает неблокирующую операцию, поэтому он будет ожидать хотя бы одно событие клавиатуры.

События будут экземплярами внутренних классов, найденных в keyboard.Events .

Прослушивание глобальных горячих клавиш.

Обычный вариант использования клавиатурных мониторов — реакция на глобальные горячие клавиши. Так как слушатель не поддерживает никакого состояния, то горячие клавиши, использующие сочетания несколько клавиш, должны где-то хранить это состояние.

Для этой цели модуль pynput предоставляет класс keyboard.HotKey . Он содержит два метода для обновления состояния, предназначенных для простого взаимодействия со слушателем клавиатуры: keyboard.HotKey.press и keyboard.HotKey.release , которые можно напрямую передавать в качестве обратных вызовов слушателя.

Предполагаемое использование выглядит следующим образом:

from pynput import keyboard def on_activate(): print('Активирована глобальная горячая клавиша!') def for_canonical(f): return lambda k: f(l.canonical(k)) # определение горячей клавиши hotkey = keyboard.HotKey( keyboard.HotKey.parse('++h'), on_activate) with keyboard.Listener( on_press=for_canonical(hotkey.press), on_release=for_canonical(hotkey.release)) as l: l.join() 

Представленный код создаст горячую клавишу, а затем использует слушатель для обновления ее состояния. Как только все указанные клавиши одновременно будут нажаты, будет вызвана функция on_activate() .

Обратите внимание, что ключи передаются через keyboard.Listener.canonical перед передачей экземпляру keyboard.HotKey . Это делается для того, чтобы удалить любое состояние модификатора из ключевых событий и нормализовать модификаторы с более чем одной физической клавишей.

Метод keyboard.HotKey.parse — это удобная функция для преобразования строк быстрого доступа в наборы ключей. для получения дополнительной информации, смотрите его документацию keyboard.HotKey .

Чтобы зарегистрировать несколько глобальных горячих клавиш, используйте вспомогательный класс keyboard.GlobalHotKeys :

from pynput import keyboard def on_activate_h(): print('Нажато сочетание клавиш: ++h') def on_activate_i(): print('Нажато сочетание клавиш: ++i') with keyboard.GlobalHotKeys( '++h': on_activate_h, '++i': on_activate_i>) as h: h.join() 

• КРАТКИЙ ОБЗОР МАТЕРИАЛА.
• Мониторинг и управление клавиатурой
• Мониторинг за состоянием и управление мышью
• Класс keyboard.Controller() модуля pynput
• Класс keyboard.Listener() модуля pynput
• Класс keyboard.Key модуля pynput
• Класс keyboard.KeyCode() модуля pynput
• Класс mouse.Controller() модуля pynput
• Класс mouse.Listener() модуля pynput

Пишем локер для Windows на Python 3.x

Приветствую любителей питона. Как-то раз я невзначай сунул палец в ctypes. И знаете, мне понравилось. Особенно блок ввода с клавиатуры и мыши. И первое, что мне сбрело в голову,- «А почему бы не написать локер для винды на питоне, с разблокировкой по флешке, как ключом» (Не спрашивайте почему именно это, я сам не знаю). И тут пошло поехало моё воображение. Сейчас я распишу с чем вам придётся столкнуться для его написания.

Ну что ж, приступим!

Первым делом создадим граф часть локера. Не будем же мы делать тупо белый лист :d
Назовём . . . locker.pyw

Почему pyw? Да потому что при запуске локера вылезет консоль, которую потенциальный плохой дядя может закрыть, тогда и весь локер накроется, а оно нам не надо.

import hashlib import time import sys import os from tkinter import Tk, Entry, Label import tkinter import pyautogui import threading from lofu import *

Импортируем библиотеки для locker.pyw

* hashlib нам нужен для сохранения ключа в хэш виде, так меньше шансов на лом (если вам это не нужно, можете не импортировать!)

* time просто для sleep()

* sys для красивого выхода exit()

* os для старта задачи части локера system()

* tkinter это и есть наша граф часть

* pyautogui для смещения мыши в угол (пусть подумает над свои поведением)

* threading для второго потока смещения мыши (чтобы не мешалась основному потоку)

* lofu . . . . я накинул пару функций, просто в другой файл и всё, я художник, я так вижу!

Сделаем функцию смещения мыши в сторону, чтобы пользователь не успел никуда нажать.

def mouse_trac(screen_width, screen_height): while True: pyautogui.moveTo(screen_width, screen_height)

pyautogui.moveTo(screen_width, screen_height) — сместить курсор по указанным координатам (в нашем случае в правый нижний угол, что равно размерам экрана)

screen_width, screen_height это размер вашего экрана
Теперь нужно вызвать Tk(), чтобы сделать граф начинку, а после и получить размеры этого самого экрана

root = Tk() root.attributes('-fullscreen', True) pyautogui.FAILSAFE = False screen_width = root.winfo_screenwidth() screen_height = root.winfo_screenheight()

root.attributes(‘-fullscreen’, True) — выводит нашу граф часть в полноэкранный режим.

pyautogui.FAILSAFE = False — отключает установленную по умолчанию в библиотеке защиту, на случай прямых рук.

screen_width = root.winfo_screenwidth() screen_height = root.winfo_screenheight() — собственно, наши размеры экрана

Вот мы и получили размеры экрана, теперь можно и запускать поток

x = threading.Thread(target=mouse_trac, args=(screen_width, screen_height), daemon=True) x.start()

target=mouse_trac — цель, а именно функция для которой необходимо выделить поток

args=(screen_width, screen_height) — какие переменки передавать функции

daemon=True — работать отдельно ото всех или поочерёдно

Подробнее читайте в документации к Threading

Теперь сделаем граф начинку

label = Label(root, text='Enter flesh drive with code!', font='Courier 15', fg='#C71585') label.place(relx=.5, rely=.94, anchor="center") label3 = Label(root, text='USBCODE waiting. ', font='Courier 20', fg='#00BFFF') label3.place(relx=.5, rely=.40, anchor="center") label4 = Label(root, text='Powered by . wait. by who?', font='Courier 15', fg='#C71585') label4.place(relx=.1, rely=.95, anchor="center") root.update()

label = Label(root, text=’Enter flesh drive with code!’, font=’Courier 15′, fg=’#C71585′) label.place(relx=.5, rely=.94, anchor=»center») — это наша заставка

root — какую именно граф часть мы хотим изменить

text — ну понятное дело текст :G

fg — цвет в формате HTML цветов ( https://colorscheme.ru/html-colors.html )

relx — положение чего либо относительно X

rely — положение чего либо относительно Y

anchor=»center» — как будет расположен текст

root.update() — обновляет граф часть (считайте что это CTRL+S)

Подробнее читайте в документации Tkinter

Теперь нужно как сделать локер ввода с клавиатуры и мыши.
Вот тут я сделал костыль.

Проблема в том, чтобы заблокировать ввод необходимы права администратора. Так как мы собираемся сделать работу в один клик, нажимать на выскакивающее окно «повышения прав» не очень хочется, поэтому воспользуемся тем что нам даёт сама windows. В windows есть очень полезная утилита «Планировщик заданий». Мы сделаем бесконечный цикл который будет проверять в определённом месте, определённое значение и решать, блокировать ввод или нет. А запускать мы его будет как раз из Планировщика заданий с наивысшими правами (При запуске скрипта в планировщике задач, не будет запрашиваться повышение прав, что нам и нужно ).

• Нажмите «Создать задачу»
• В поле «Имя» введите на свой каприз любое название (желательно слитно)
• Снизу обязательно нажмите на галочку «Выполнить с наивысшими правами»

• Всё, больше не трогаете вкладку «Общие»
• Откройте вкладку «Триггеры»
• Добавьте триггеры : «При входе в систему» и «Один раз (Однократно, повторять задачу каждые 1 минуту, в течении Бесконечно)«

• Откройте вкладку «Действия»
• Создайте действие «Запуск программы»

• А теперь стоп! Что мы будем запускать? . . .

Создаём файл с бесконечным циклом про который мы говорили чуть выше. Назовём его input_block.pyw

from ctypes import * import time import sys from lofu import * while True: statusl = status_lock() if str(statusl) == '0': windll.user32.BlockInput(False) elif str(statusl) == '1': windll.user32.BlockInput(True)

Теперь сделаем lofu

def status_lock(): filee = open(r'Путь до файла', 'r') return filee.read() filee.close() def disable_lock(): filee = open(r'Путь до файла', 'w') text = 0 filee.write(str(text)) filee.close() def enable_lock(): filee = open(r'Путь до файла', 'w') text = 1 filee.write(str(text)) filee.close()

Да, да я знаю что вы хотите сказать: «ФУУУУ ЮЗАЕШЬ ТУПА ФАЙЛ, КАК ТАК МОЖНО? ВСЕ ДАВНО ЛИБО ЛОКАЛЬНУЮ БД ЛИБО JSON ИСПОЛЬЗУЮТ! МУСОР!»

Вы конечно можете юзать json, sqlite3 и тд. Это не меняет сути. Как пример я просто использую файл. Всё!

Теперь нам нужно сделать из input_block.pyw >> input_block.exe
Для этого используем pyinstaller

pyinstall input_block.pyw --onefile

Что? Нет pyinstaller?

pip install pyinstaller

Для полученного файла делаем ярлык и ставим ему флажок «Запускать от имени Администратора».

Возвращаемся к «Планировщику заданий» и в поле «Программа или сценарий» вводим адрес до ярлыка.

Возвращаемся к нашему locker.pyw

os.system('schtasks.exe /run /tn "ИМЯ ВАШЕЙ ЗАДАЧИ В ПЛАНИРОВЩИКЕ ЗАДАНИЙ"')

Отлично, а теперь осталось лишь доделать граф часть, блокировку и разблокировку

while True: try: enable_lock() file = open(r'F:\key.txt','r') file_t = str(file.read()) file.close() hash_object = hashlib.sha256(file_t.encode()) hex_dig = hash_object.hexdigest() if 'ВАШ ХЕШ-КЛЮЧ' == str(hex_dig): label3.configure(text='USBCODE correct. Unlocking. ', fg='#00FF00', font="Courier 30") root.update() time.sleep(4) disable_lock() sys.exit() else: label3.configure(text='USBCODE incorrect. Try again!', fg='#FF0000', font="Courier 30") enable_lock() root.update() except SystemExit: sys.exit() except: time.sleep(10) label3.configure(text='USBCODE not found! Waiting. ', fg='#FF1493', font="Courier 20") enable_lock() root.update()

Тут уже на вкус, кому как нравиться. Регулируйте задержки, текст

enable_lock() — функция lofu которая активирует лок ввода

disable_lock() — функция lofu которая де-активирует лок ввода

time.sleep(N) — задержка

file = open(r’F:\key.txt’,’r’)
file_t = str(file.read())
file.close() — читаем файл на флешке с нашим ключом, если он конечно есть

hash_object = hashlib.sha256(file_t.encode())
hex_dig = hash_object.hexdigest() — а это уже сама хэш функция

if ‘ВАШ ХЕШ’ == str(hex_dig): — я вам что ещё как иф работает объяснять должен :d
Хэш получаете очень просто:
* Придумайте какую-нибудь комбинацию (Для восстановления, если забыли, потеряли, утопили флешку)
* Сделайте хэш этой комбинации (Это ключ вашей флешки)
* Сделайте хэш вашего хеша (Это хэш-ключ в locker.pyw)

Всё, теперь нужно подумать об автостарте locker.pyw.

Можно через реестр, shell:startup, да даже через «Планировщик заданий».

На этом всё. Я вас поздравляю! Мы только что сделали локер для Windows на Python 3.x c полной блокировкой ввода через «Планировщик заданий», с разблокировкой через флешку, с хэш ключом и граф интерфейсом!

P.S. можно ещё поставить в ярлык locker.pyw в поле «Быстрый вызов» бинд клавиш для быстрой блокировки.

Руководство по модулю клавиатуры Python 25.09.2021 20:01

Python является одним из наиболее подходящих языков для автоматизации задач. Будь то повторяемый (этический) веб-скоб через некоторое время, запуск некоторых программ при запуске компьютера или автоматизацию отправки повседневных электронных писем, Python имеет много модулей, которые облегчают вашу жизнь.

Одним из них является модуль под названием keyboard, который полностью контролирует вашу клавиатуру. С помощью данного модуля вы можете печатать что угодно, создавать горячие клавиши, сокращения, блокировать клавиатуру, ждать ввода и т. д.

В этом руководстве мы рассмотрим, как настроить и использовать модуль клавиатуры в Python.

Примечание: Приложения, работающие с автоматизацией человекоподобных процессов, должны разрабатываться этично и ответственно. Модуль клавиатуры сделан так, чтобы быть очень заметным, и, таким образом, делает его одновременно обескураживающим и прозрачным, если кто-то использует его для создания клавиатурных шпионов или вредоносных ботов.

Установка модуля клавиатуры

Версия Python, используемая в этом руководстве, равна 3.8. Однако модуль клавиатуры может работать как с Python 2.x, так и с Python 3.x.

Если вы используете Linnux, чтобы использовать эту библиотеку, вы должны установить ее от root. Если вы этого не сделаете, вы получите:

ImportError: You must be root to use this library on linux.

Кроме того, при запуске сценария вы должны запускать его с правами суперпользователя:

$ sudo pip3 install keyboard $ sudo python3 my_script.py

В Windows и macOS, поскольку привилегии работают совсем по-другому — вы можете установить его просто через pip и запустить сценарии:

$ pip install keyboard $ python my_script.py

Примечание: Для MacOS вам, возможно, придется разрешить терминалу или другим приложениям изменять состояние вашей машины, например, путем ввода текста. Также имейте в виду, что по состоянию на сентябрь 2021 года библиотека все еще находится в экспериментальном состоянии на MacOS.

Функция модуля клавиатуры

В этом модуле есть много функций, которые можно использовать для имитации действий клавиатуры.

• keyboard.write (message, [delay])- пишет сообщение с задержкой или без нее.
• keyboard.wait (key) — блокирует программу до тех пор, пока не будет нажата клавиша. Ключ передается в виде строки («пробел», «esc» и т.д.)
• keyboard.press (key)- нажимает клавишу и удерживается до вызова функции release (key)
• keyboard.release (key)- выпускает ключ.
• keyboard.send (key)- нажимает и отпускает клавишу.
• keyboard.add_hotkey (hotkey, function)- создает hotkey, которая при нажатии выполняет function.
• keyboard.record (key)- записывает активность клавиатуры до нажатия key.
• keyboard.play (recorded_events, [speed_factor]) — воспроизводит события, записанные with keyboard.record (key) функция, с дополнительным speed_factor.

Тем не менее, мы рассмотрим все это. Вот быстрый пример:

>>> import keyboard >>> keyboard.write("Hello") >>> Hello

Приветственное сообщение появляется на экране в терминале, как будто вы его написали. Вы можете очень легко автоматизировать команду и создать для нее псевдоним горячей клавиши. Вот (грубый) пример выхода из REPL Python, написания команды curl:

>>> import keyboard >>> keyboard.write("exit()"); keyboard.send("enter"); keyboard.write("curl https://www.google.com"); keyboard.send("enter"); >>> exit() curl https://www.google.com $ curl https://www.google.com  

import keyboard while True: keyboard.wait("1") keyboard.write("\n The key '1' was pressed!")

>>> import keyboard >>> from time import sleep >>> keyboard.press("a") >>> sleep(1) >>> keyboard.release("a") >>> a

>>> keyboard.press("shift") >>> keyboard.write("lowercase") >>> keyboard.release("shift") >>> LOWERCASE

import keyboard recorded_events = keyboard.record("esc") keyboard.play(recorded_events)

KeyboardEvent(w up), KeyboardEvent(o down), . ]

import keyboard recorded_events = keyboard.record("s") keyboard.send("w") keyboard.send("a") keyboard.play(recorded_events)

import keyboard while True: keyboard.wait("s") keyboard.press("ctrl+shift+s") # Or for MacOS keyboard.press("command+shift+s)

>>> import keyboard >>> keyboard.add_abbreviation("@", "john@stackabuse.com")

import keyboard keyboard.add_hotkey("ctrl+alt+j", lambda: print("ctrl+alt+j was pressed"))