Python - Suppress input while writing to window

[Paraskevas Petsanas]

Hi,
I am developing an app that monitors and corrects the user input based on some rules.
I am reading the events from keyboard with the keyboard python module.
I faced some problem when the user types very fast, as regards some overlays of text. By this I mean that when my app writes the correct input, the user continues writing and may writes before the corrector types the whole word.
I found, that I can start a keyboard hook with suppressed output to screen and tried to implements a solution.
In the above code I tried recreating the problem and tried giving the general idea. 

```
import keyboard
from collections import deque

string : str = ""
counter : int = 0
is_suppressed: bool = False # this indicates if letters are shown in the window or not
suppressed_string: str = ""
q = deque() # this is used as a buffer, and stores the words that are entered when the
# program is correcting


def keyboard_module_write_to_screen(is_suppressed, string):
        for i in range(len(string) + 1):
            print("--Pressing backspace--")
            keyboard.press_and_release('backspace')
        for i, char in enumerate (string): # simulating a calculation 
            final_char_to_be_written = char.upper()
            print("---WRITING THE CHAR -> {} ---".format(final_char_to_be_written))
            keyboard.write(final_char_to_be_written)
        for i in range(30):
            keyboard.write('*')
        keyboard.write(' ')

def monitoring(event):
        global counter, string, is_suppressed, suppressed_string

        if (event.event_type == keyboard.KEY_DOWN): # and event.name != 'backspace'):
            print("-String entered : {}".format(event.name))

            if (event.name == 'space'):
                # if space is button a new word is entered
                if (is_suppressed is True):
                    # if program occupied writing to the screen save the word to the buffer
                    q.appendleft(suppressed_string)
                    suppressed_string = ""

                elif (is_suppressed is False):
                        # check and write first from the deque,
                        # write the word(s) that were stored in the buffer before writing current
                        # input string
                        # haven't find a way to do the above alongside the others
                        keyboard.unhook_all()
                        keyboard.hook(monitoring, suppress = True)

                        is_suppressed = True

                        keyboard_module_write_to_screen(is_suppressed, string)

                        keyboard.unhook_all()
                        keyboard.hook(monitoring, suppress = False)
                        is_suppressed = False
                        counter = 0
                        string = ""

            elif (event.name in "abcdefghijklmnopqrstuvwxyz") :
                if (is_suppressed is True):
                    suppressed_string = ''.join([suppressed_string, event.name])
                    print("########## SUPPRESSED_STRING = {} #########".format(suppressed_string))

                counter = counter + 1
                print("-- COUNTER is : {}".format(counter))
                string = ''.join([string, event.name])
            elif (event.name == "]"):
                    print(q)
            elif (event.name == 'backspace'):
                pass

keyboard.hook(monitoring, suppress = False)
```
The main thing I want to achieve is
1)while correcting - writing to the window, read events and save them to a buffer
2)when correcting - writing is done check the buffer, write it's content, but keep reading events
3)if buffer empty and currently not writing something, read events etc.
I didn't manage to make it work and produce the desired result.
Any advice on how to make it work, would be useful.
Thanks in advance for any help.