Nsryjdtyk

I'm creating a PyQt Application. The main core/logic of the program runs in a separate loop I've created on a new thread. The core needs to be listening for defined hotkeys that will in turn trigger some functionality. I've removed all the logic and just made a dummy test scenario, as I'm really looking for feedback/help on structure/architecture. I'm very new to all of this.

I created a Keyboard class that also runs in its own thread, where you can register functions that will get called when a key is pressed.

import threading

from win32 import win32api

import win32con

import pythoncom

import pyHook



class Keyboard(threading.Thread):

    def __init__(self):

        super().__init__()

        self.hook_manager = pyHook.HookManager()

        self.hook_manager.KeyDown = self.on_keyboard_event



        self._callbacks = 



        self.is_running = False



    def stop(self):

        self.is_running = False

        self.hook_manager.UnhookKeyboard()



    def run(self):

        self.is_running = True

        self.hook_manager.HookKeyboard()



        while self.is_running:

            pythoncom.PumpWaitingMessages()



    def press(*args):

        for arg in args:

            win32api.keybd_event(arg, 0, 0, 0)



    def release(*args):

        for arg in args:

            win32api.keybd_event(arg, 0, win32con.KEYEVENTF_KEYUP, 0)



    def register_callback(self, f):

        self._callbacks.append(f)



    def on_keyboard_event(self, event):

        print(event.KeyID)

        for callback in self._callbacks:

            callback(event)



        return True

Now the core of the application. It has two main functions: it needs to switch between when running and the second one needs to run for a set amount of time then revert back to the first. The way I've handled this switching and looping seems really bad.

import time





class ThreadedTask(threading.Thread):

    MODE_ONE = 0

    MODE_TWO = 1



    def __init__(self):

        super().__init__()

        self.is_running = False

        self.processing_mode = 0



        self.x = 0



        self.keyboard = Keyboard()

        self.keyboard.register_callback(self.key_pressed)

        self.keyboard.start()



    def stop(self):

        self.is_running = False



    def run(self):

        self.is_running = True



        while self.is_running:

            if self.processing_mode == ThreadedTask.MODE_ONE:

                self.function_one()

            elif self.processing_mode == ThreadedTask.MODE_TWO:

                self.function_two()



    def function_one(self):

        print("function_one")

        y = self.x + 2



        if y == 4:

            self.processing_mode = 1

            self.x = 0



        time.sleep(0.3)



    def function_two(self):

        timeout = time.time() + 5

        while self.processing_mode == ThreadedTask.MODE_TWO and time.time() < timeout:

            print("function_two")

            time.sleep(0.3)



        self.processing_mode = 0



    def key_pressed(self, event):

        self.x = 2

And lastly, I feel like I'm going to encounter race conditions, what if the Keyboard calls the key_pressed function which modifies the value of x while function_one is trying to access x. I know very little about threading, this is the first time I've tried it. The above code runs fine in my tests, but I read that race conditions are unpredictable, so that it running fine doesn't necessarily mean there isn't a problem.

To run the program:

task = ThreadedTask()

task.start()