Como executar tarefas assíncronas nos aplicativos Python GObject Introspection

Estou escrevendo um aplicativo Python + GObject que precisa ler uma quantidade não trivial de dados do disco no início. Os dados são lidos de forma síncrona e leva cerca de 10 segundos para concluir a operação de leitura, período durante o qual o carregamento da interface do usuário é atrasado.

Gostaria de executar a tarefa de forma assíncrona e receber uma notificação quando estiver pronta, sem bloquear a interface do usuário, mais ou menos como:

def take_ages():
    read_a_huge_file_from_disk()

def on_finished_long_task():
    print "Finished!"

run_long_task(task=take_ages, callback=on_finished_long_task)
load_the_UI_without_blocking_on_long_task()

Eu usei o GTask no passado para esse tipo de coisa, mas estou preocupado que seu código não seja tocado em três anos, muito menos tenha sido portado para o GObject Introspection. Mais importante, ele não está mais disponível no Ubuntu 12.04. Portanto, estou procurando uma maneira fácil de executar tarefas de forma assíncrona, tanto no modo Python padrão quanto no GObject / GTK +.

Edit: aqui está um código com um exemplo do que estou tentando fazer. Tentei python-deferconforme sugerido nos comentários, mas não consegui executar a tarefa longa de forma assíncrona e deixar a interface do usuário carregar sem ter que esperar a conclusão. Procure o código de teste .

Existe uma maneira fácil e amplamente usada de executar tarefas assíncronas e ser notificado quando elas terminarem?

Seu problema é muito comum, portanto, existem inúmeras soluções (galpões, filas com multiprocessamento ou encadeamento, pools de trabalhadores, ...)

Por ser tão comum, também existe uma solução embutida em python (na 3.2, mas com suporte aqui: http://pypi.python.org/pypi/futures ) chamada concurrent.futures. 'Futuros' estão disponíveis em vários idiomas; portanto, python os chama da mesma forma. Aqui estão as chamadas típicas (e aqui está o seu exemplo completo , no entanto, a parte db é substituída por sleep, veja abaixo o porquê).

from concurrent import futures
executor = futures.ProcessPoolExecutor(max_workers=1)
#executor = futures.ThreadPoolExecutor(max_workers=1)
future = executor.submit(slow_load)
future.add_done_callback(self.on_complete)

Agora, para o seu problema, que é muito mais complicado do que o seu exemplo simples sugere. Em geral, você tem threads ou processos para resolver isso, mas aqui está o porquê de seu exemplo ser tão complicado:

1. A maioria das implementações do Python possui um GIL, que faz com que os threads não utilizem totalmente multicores. Então: não use threads com python!
2. Os objetos que você deseja retornar slow_loaddo banco de dados não são selecionáveis, o que significa que eles não podem simplesmente ser passados ​​entre processos. Portanto: não há multiprocessamento com resultados do softwarecenter!
3. A biblioteca que você chama (softwarecenter.db) não é thread-safe (parece incluir gtk ou similar), portanto, chamar esses métodos em um thread resulta em um comportamento estranho (no meu teste, tudo, desde 'funciona' sobre 'core dump' até simples sair sem resultados). Portanto: sem threads com o softwarecenter.
4. Todo retorno de chamada assíncrono no gtk não deve fazer nada, exceto eliminar um retorno de chamada que será chamado no mainloop glib. Portanto: não print, nenhum estado do gtk muda, exceto a adição de um retorno de chamada!
5. Gtk e similares não funcionam com threads fora da caixa. Você precisa fazer isso threads_inite, se você chamar um método gtk ou semelhante, precisará protegê-lo (nas versões anteriores, isso eragtk.gdk.threads_enter() , gtk.gdk.threads_leave()veja. Por exemplo, gstreamer: http://pygstdocs.berlios.de/pygst-tutorial/playbin. html ).

Eu posso lhe dar a seguinte sugestão:

1. Reescreva seu slow_loadpara retornar resultados selecionáveis ​​e usar futuros com processos.
2. Mude do softwarecenter para python-apt ou similar (você provavelmente não gosta disso). Mas como você trabalha na Canonical, você pode pedir diretamente aos desenvolvedores do softwarecenter para adicionar documentação ao software (por exemplo, declarar que não é seguro para threads) e, melhor ainda, tornar o softwarecenter seguro.

Como uma nota: as soluções dadas pelos outros ( Gio.io_scheduler_push_job, async_call) fazer o trabalho com time.sleepmas não com softwarecenter.db. Isto é, porque tudo se resume a threads ou processos e threads para não funcionar com o gtk e softwarecenter.

Aqui está outra opção usando o GIO I / O Scheduler (nunca o usei antes no Python, mas o exemplo abaixo parece funcionar bem).

from gi.repository import GLib, Gio, GObject
import time

def slow_stuff(job, cancellable, user_data):
    print "Slow!"
    for i in xrange(5):
        print "doing slow stuff..."
        time.sleep(0.5)
    print "finished doing slow stuff!"
    return False # job completed

def main():
    GObject.threads_init()
    print "Starting..."
    Gio.io_scheduler_push_job(slow_stuff, None, GLib.PRIORITY_DEFAULT, None)
    print "It's running async..."
    GLib.idle_add(ui_stuff)
    GLib.MainLoop().run()

def ui_stuff():
    print "This is the UI doing stuff..."
    time.sleep(1)
    return True

if __name__ == '__main__':
    main()

Você também pode usar o GLib.idle_add (retorno de chamada) para chamar a tarefa de longa execução quando o Mainloop do GLib concluir todos os seus eventos de maior prioridade (que eu acredito que inclui a construção da interface do usuário).

Use a GioAPI introspectada para ler um arquivo, com seus métodos assíncronos, e ao fazer a chamada inicial, faça isso como um tempo limite com GLib.timeout_add_seconds(3, call_the_gio_stuff)where call_the_gio_stuffé uma função que retornaFalse .

O tempo limite aqui é necessário adicionar (embora seja necessário um número diferente de segundos), porque, embora as chamadas Gio assíncronas sejam assíncronas, elas não são bloqueadoras, o que significa que a atividade pesada do disco de ler um arquivo grande ou grande número de arquivos, pode resultar na interface do usuário bloqueada, pois a interface do usuário e a E / S ainda estão no mesmo encadeamento (principal).

Se você deseja escrever suas próprias funções para ser assíncrono e integrar-se ao loop principal, usando as APIs de E / S de arquivos do Python, precisará escrever o código como um GObject, ou repassar retornos de chamada ou usar python-deferpara ajudá-lo. faça. Mas é melhor usar o Gio aqui, pois ele pode oferecer muitos recursos interessantes, principalmente se você estiver abrindo / salvando arquivos no UX.

Acho que vale a pena notar que essa é uma maneira complicada de fazer o que o @mhall sugeriu.

Essencialmente, você pode executar isso e executar a função async_call.

Se você quiser ver como ele funciona, você pode jogar com o temporizador e continuar clicando no botão. É essencialmente o mesmo que a resposta de @ mhall, exceto que há um código de exemplo.

Com base nisso, esse não é o meu trabalho.

import threading
import time
from gi.repository import Gtk, GObject



# calls f on another thread
def async_call(f, on_done):
    if not on_done:
        on_done = lambda r, e: None

    def do_call():
        result = None
        error = None

        try:
            result = f()
        except Exception, err:
            error = err

        GObject.idle_add(lambda: on_done(result, error))
    thread = threading.Thread(target = do_call)
    thread.start()

class SlowLoad(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Hello World")
        GObject.threads_init()        

        self.connect("delete-event", Gtk.main_quit)

        self.button = Gtk.Button(label="Click Here")
        self.button.connect("clicked", self.on_button_clicked)
        self.add(self.button)

        self.file_contents = 'Slow load pending'

        async_call(self.slow_load, self.slow_complete)

    def on_button_clicked(self, widget):
        print self.file_contents

    def slow_complete(self, results, errors):
        '''
        '''
        self.file_contents = results
        self.button.set_label(self.file_contents)
        self.button.show_all()

    def slow_load(self):
        '''
        '''
        time.sleep(5)
        self.file_contents = "Slow load in progress..."
        time.sleep(5)
        return 'Slow load complete'



if __name__ == '__main__':
    win = SlowLoad()
    win.show_all()
    #time.sleep(10)
    Gtk.main()

Observação adicional: você deve deixar o outro encadeamento terminar antes que ele termine corretamente ou procurar um arquivo.lock no encadeamento filho.

Editar para endereçar o comentário:
Inicialmente esqueci GObject.threads_init(). Evidentemente, quando o botão disparou, ele inicializou o threading para mim. Isso mascarou o erro para mim.

Geralmente, o fluxo é criar a janela na memória, iniciar imediatamente o outro encadeamento, quando o encadeamento terminar atualizar o botão. Adicionei um sono adicional antes mesmo de ligar para Gtk.main para verificar se a atualização completa PODE ser executada antes mesmo da janela ser desenhada. Também comentei isso para verificar se o lançamento do thread não impede o desenho da janela.