Python - Interrupcion de software en python

Tengo un problema, me dejaron hacer una interrupcion de sotware pero no se cual seria la instruccion o el evento que me permite hacer dicha interrupcion, gracias de antemano, este es el codigo que he hecho:

#!/usr/bin/env python

import time
import math
import pygtk
import gtk
from threading import Thread, Semaphore

Flag = True

############################################################################
# CLASE PROCESO #
############################################################################
class Proceso( Thread ):
def __init__( self , a, b, car, Sem ):
self.num1 = a
self.num2 = b
self.caracter = car
self.Semaf = Sem
self.dif = 0
self.info = "Proceso: " + str(a) + " " + str(car) + " " + str(b) + "\n"
self.cadena = "\nInicia proceso\n" + self.info

def regresaInfo( self ):
return self.info

def correr( self ):

Flag = False
self.timeinicio = time.time()
if self.caracter == '+':
self.suma( self.num1, self.num2 )
elif self.caracter == '-':
self.resta( self.num1, self.num2 )
elif self.caracter == '**':
self.ncuadrado( self.num1, self.num2 )
else:
self.caracter = '**'
# time.sleep( 2 )
dif = time.time() - self.timeinicio
self.cadena = self.cadena +"\n"+ str( self.dif ) + " Segundos de ejecucion\nFin de Proceso\n"
Flag = True


def regresaCadena( self ):
return self.cadena

def suma( self, a, b ):
self.cadena = self.cadena + str(a) + " + " + str( b ) + " es igual a " + str ( a + b )

def resta( self, a, b ):
self.cadena = self.cadena + str( a ) + " - " + str( b ) + " es igual a " + str( a - b )

def ncuadrado( self, a, b ):
self.cadena + str( a ) + " a la " + str(b) + " es igual a " + str( math.pow(a, b) )

#############################################################################
#############################################################################
class modulo( Thread ):
def __init__( self ):
lista = [ [12, 23, '+'],[32,324,'-'],[ 98,53, '-'],[ 123, 0, '**'],[76,45,'+'],[34,23,'-'],[1,0,'**'] ]
self.Sem = Semaphore(2)
i = 0
self.otraLista = []
self.mensajes = ""
for i in lista:
print "entro " + str (i)
process = Proceso( i[0], i[1], i[2], self.Sem )
self.otraLista.append( process )
self.mensajes = self.mensajes + process.regresaInfo()

#############################################################################
# CLASE INTERFAZ GRAFICA #
#############################################################################
class GUI( Thread ):
def __init__( self ):
self.flag = False

self.sw1 = gtk.ScrolledWindow()
self.sw2 = gtk.ScrolledWindow()
self.sw3 = gtk.ScrolledWindow()
self.sw4 = gtk.ScrolledWindow()

self.sw1.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.sw2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.sw3.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.sw4.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)

self.etiListos = gtk.Label("Listos")
self.etiNuevos = gtk.Label("Procesando")
self.etiBloqueados = gtk.Label("Bloqueados")
self.etiTerminados = gtk.Label("Terminados")

self.botonIni = gtk.Button("Iniciar")

self.window = gtk.Window( gtk.WINDOW_TOPLEVEL )
self.window.set_title( "PRACTICA 3")
self.window.connect( "delete_event", self.delete_event )
self.window.connect( "key_press_event", self.on_key_press_event )
self.window.set_border_width(6)

self.textoLis = gtk.TextBuffer()
self.textoNue = gtk.TextBuffer()
self.textoPau = gtk.TextBuffer()
self.textoBlo = gtk.TextBuffer()
self.textoTer = gtk.TextBuffer()

self.colaLis = gtk.TextView( self.textoLis )
self.colaNue = gtk.TextView( self.textoNue )
self.colaBlo = gtk.TextView( self.textoBlo )
self.colaTer = gtk.TextView( self.textoTer )

self.sw1.add_with_viewport( self.colaLis )
self.sw2.add_with_viewport( self.colaNue )
self.sw3.add_with_viewport( self.colaBlo )
self.sw4.add_with_viewport( self.colaTer )

self.sw1.show()
self.sw2.show()
self.sw3.show()
self.sw4.show()

self.tabla = gtk.Table( 15, 15, True )

self.tabla.attach( self.etiListos, 0,4,0,1)
self.tabla.attach( self.sw1, 0,4,1,6 )
self.tabla.attach( self.etiNuevos, 0,4,6,7)
self.tabla.attach( self.sw2, 0,4,7,12 )
self.tabla.attach( self.etiBloqueados, 5,9,6,7)
self.tabla.attach( self.sw3 , 5,9,7,12 )
self.tabla.attach( self.etiTerminados, 10,14,6,7)
self.tabla.attach( self.sw4, 10,14,7,12 )

self.etiInterrumpir = gtk.Label("Interrupmpir - presionar Q")
self.etiError = gtk.Label("Error - presionar A")
self.etiPausa = gtk.Label("Pausa - presionar Z")
self.etiContinuar = gtk.Label("Continuar - X")

self.tabla.attach( self.etiInterrumpir, 5,8,0,1 )
self.tabla.attach( self.etiError, 5,8,1,2 )
self.tabla.attach( self.etiPausa, 5,8,2,3 )
self.tabla.attach( self.etiContinuar, 5,8,3,4 )
self.tabla.attach( self.botonIni, 9,12,0,1)

self.window.add( self.tabla )
self.window.set_default_size(600,450)

self.botonIni.connect('clicked', self.inicio )

self.colaLis.show()
self.colaNue.show()
self.colaBlo.show()
self.colaTer.show()

self.botonIni.show()

self.etiListos.show()
self.etiNuevos.show()
self.etiBloqueados.show()
self.etiTerminados.show()
self.etiInterrumpir.show()
self.etiError.show()
self.etiPausa.show()
self.etiContinuar.show()
self.tabla.show()
self.window.show()

self.textoLis.set_text( mod.mensajes )

def main( self ):
gtk.main()

def interrupcion( self, widget, data = None ):
etiOperando = gtk.Label('Operando a tratar:')
operando = gtk.Entry()
self.dialogo = gtk.Dialog( 'Interrupcion: operacion potenciacion', None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT ) )
self.dialogo.vbox.pack_start( etiOperando )
self.dialogo.vbox.pack_start( operando )
operando.show()
etiOperando.show()
response = self.dialogo.run()
self.textoLis.set_text( "Proceso: "+operando.get_text()+"\n"+self.textoLis.get_text( self.textoLis.get_start_iter(), self.textoLis.get_end_iter() ) )
self.dialogo.destroy()

def error( self, widget, data ):
if self.flag == False:
self.textoBlo.set_text( data )
self.flag = True
else:
self.textoBlo.set_text( self.textoBlo.get_text(self.textoBlo.get_start_iter(), self.textoBlo.get_end_iter() ) + data + '\n' )

def inicio(self, widget, data = None):
i = 0
while i < 7 :
self.textoNue.set_text( mod.otraLista[i].cadena )
mod.otraTupla[i].correr()
if i == 1 :
self.textoTer.set_text( mod.otraLista[i].cadena )
else:
self.textoTer.set_text( self.textoTer.get_text(self.textoTer.get_start_iter(), self.textoTer.get_end_iter() ) + mod.otraLista[i].cadena + '\n' )
i = i + 1
time.sleep(1)
return True

def delete_event( self, widget, event, data = None ):
gtk.main_quit()
return gtk.FALSE

def on_key_press_event(self, widget, event):
keyname = gtk.gdk.keyval_name(event.keyval)
print "Key %s (%d) was pressed" % (keyname, event.keyval)
if event.keyval == 113:
self.interrupcion( widget, event )
if event.keyval == 97:
self.interrupcion( widget )
if event.keyval == 122:
self.interrupcion( widget )
if event.keyval == 120 :
self.interrupcion( widget )

if __name__=="__main__":
mod = modulo()
g = GUI()
g.main()

Hola Oliver, no entiendo muy bien a que te refieres con interrupción... te refieres a detener el código para poder visualizar las variables, valores, etc...?
Si es así, te recomiendo utilizar ipdb...

Coméntanos, ok?

Mas bien ando buscando como hacer que mientras aun continua ejecutandose la funcion de retrollamada asociada al boton, parar su ejecucion para ejecutar otro bloque de codigo

Actualmente estoy creando una aplicación gráfica que maneja interrupciones.
Lo que hago es lo siguiente:
El programa se ejecuta normalmente.
Si se genera una interrupción,por ejemplo,un evento generado en una ventana gráfica,
se asocia el evento de la ventana a una función que hará lo siguiente.
1)Almacenar el valor de todas las variables que contiene tu programa
en una lista que se utilizara como pila de llamadas.Esto es para que cuando
la interrupción realice su trabajo,al retornar al punto en el que se genero la interrupción
podamos tener el valor de las variables con que trabajamos en ese momento.Esto suponiendo
que la interrupción cambia el valor de tus variables.

2)Ejecutar la interrupción

3)Asignar a cada variable de tu programa el valor que le
corresponde y que esta almacenado en la lista anteriormente descrita.


RESUMEN
*Programa ejecutandose
*si se detecta un evento: (ESTO EL LENGUAJE LO DETECTA AUTOMATICAMENTE)
*el lenguaje de programacion ira a la funcion asociada al evento
*la funcion del evento debe guardar en una lista el valor de todas tus variables
*se ejecuta el codigo de la interrupcion
*asignar a las variables el valor que le corresponde dentro de la lista
*el lenguaje de programacion continuara automaticamente en el punto en que se genero
la interrupcion.