How terminate a loop inside a method of class (object) without wait to end

I see a lot of objects that stop or terminate because they are a Thread. So i saw things like this in the init:

      self._event = threading.Event()
      self._thread = threading.Thread(target=self._run, name="PlayThreading")

and later a method like this:

def start(self):
        """delegate to threading.Thread.start()"""
        self._thread.start()
        
def stop(self):
        self._event.set()
        self._thread.join()

And this to terminate:

 if self._event.is_set(): 
                break

so, my class is not a class that will be a Thread. So my object do his thing and “desappear” (i think). But… have a “while” inside. And the problem is that i need to have the positilities to break that while at any time.
Because, for example i have a menu that have the option to “resign”. The problem is that my user can do the resign while the code is in the class that have the “while”.

This is my break mood class:

class physical_move:
    def __init__(self,opponent_move=None, start=False): #!El move que envié acá que sea siempre recortado es decir [0:4]
        self.opponent_move = opponent_move
        self.start = start
        self.lst = []
        self.dirx = []
        self.move = ""
        self.terminate = False

        if start == True:
            self.moving()
    
    def __repr__(self):
        return self.move

    def stop(self):
        self.terminate = True

    def moving(self):
        
        if self.opponent_move != None:
            self.turnOnLed()
            
        while self.terminate is False: #Sadly this was dumb...
            self.cambio_tablero()
            self.move = (''.join(self.lst))
            
            if self.dirx == ["open", "close"]:
                return self.move
            
            elif self.dirx == ["open", "open", "close"]:
                self.move = self.move[0:4]
                return self.move
            
            elif self.dirx == ["close"] or self.dirx == ["open","open","open"]:
                self.move = "0000"
                return self.move
            
    def turnOnLed(self):
        x,y = led_dic[self.opponent_move[0:2],] #Inicio de movimiento
        matrix.toggleLED(x,y)
        x1,y1 = led_dic[self.opponent_move[2:4],] #Destino de movimiento
        matrix.toggleLED(x1,y1) 

    def special_moves(self,special_dirx):
        while self.dirx != special_dirx:
            if self.terminate:
                break            
            self.cambio_tablero()
            print(self.dirx)
            print(special_dirx)
            time.sleep(1)



    def cambio_tablero(self):
        while True:
            try:
                if self.terminate:
                    break
                for k in range(0,4): #loops round 4 registers of MCP23017
                    for l in range(2):  # for each MCP register A and B
                        a = bus[k].read_byte_data(DEVICE[k],GPIOn[l])
                    
                        if a != mbrd[(k*2)+l]: # Hubo un cambio
                            c = a ^ mbrd[(k*2)+l]  # bitwise operation copies the bit if it is set in one operand but not both.
                            #Las coordenadas del cambio
                            x = chcol[(k*2)+l] 
                            y = str(math.frexp(c)[1])
                        
                            if iblack == True:
                                y = black_numbers[y]
                                
                            move = x + y #Es sólo una coordinada x ej: "a2", es decir no el movimiento entero.
                            #que tipo de cambio fue:
                            if a > mbrd[(k*2)+l] :
                                self.dirx.append("open")
                                if self.opponent_move == None:
                                    x,y = led_dic[move,] #Acordate lo de value
                                    matrix.toggleLED(x,y)

                            if a < mbrd[(k*2)+l] :
                                self.dirx.append("close")
                                if self.opponent_move == None:
                                    x,y = led_dic[move,] #Acordate lo de value
                                    matrix.toggleLED(x,y)

                            mbrd[(k*2)+l]= a #Actualiza la posición del tablero
                            self.lst.append(move) #No olvidar que lst (la lista) es el verdadero movimiento (entero)   
                        
                        time.sleep(0.02) #al final acá por el "for"

            except Exception as exception:
                print("Exception: {}".format(type(exception).__name__))
                print("Exception message: {}".format(exception))
                continue
            break

I think in the method “stop” but that was silly. I cant run that stop method if im still in the while of the method.

This class is called by other class that is a separated thread, and even if i terminate the “superior” class that is a thread, that dont kill the while in this physical_move class.
What can i do? i can take advantage in any way that this class is called for other class? or?