Tentando corrigir os congelamentos da GUI do tkinter (usando threads)

Tenho um criador de relatórios Python 3.x que é vinculado à E / S (devido ao SQL, não ao python) que a janela principal "trava" paraminuto enquanto os relatórios estão sendo criado

Tudo o que é necessário é a capacidade de usar as ações padrão da janela (mover, redimensionar / minimizar, fechar etc.) enquanto a GUI está bloqueada (tudo o resto na GUI pode permanecer "congelado" até que todos os relatórios sejam concluídos) .

Added 20181129: Em outras palavras, o tkinter deve controlar apenas o CONTEÚDO da janela do aplicativo e deixar o controle de todos os controles de janela padrão (externos) para o SO. Se eu puder fazer isso, meu problema desaparecerá e não preciso usar todos os threads / subprocessos (os congelamentos se tornam um comportamento aceitável, semelhante ao desabilitar o botão "Fazer relatórios").

Qual é a maneira mais fácil / mais simples (=mínim perturbação do código existente) de fazer isso - idealmente de uma maneira que funcione com Python> = 3.2.2 e de uma plataforma cruzada (ou seja, funcione em pelo menos Windows e linux

Tudo abaixo contém informações de suporte que explicam o problema com mais detalhes, abordagens tentadas e alguns problemas sutis encontrado

Coisas a considerar

s usuários @ escolhem seus relatórios e pressionam o botão "Criar relatórios" na janela principal (quando o trabalho real é iniciado e o congelamento ocorre). Após a conclusão de todos os relatórios, o código de criação do relatório exibe uma janela "Concluído" (nível superior). Fechar esta janela ativa tudo na janela principal, permitindo que os usuários saia do programa ou crie mais relatórios.

Added 20181129: Em intervalos aparentemente aleatórios (com vários segundos de diferença) eu posso mover a janel

Exceto por exibir a janela "Concluído", o código de criação do relatório não envolve a GUI ou o tkinter de forma algum

Alguns dados produzidos pelo código de criação do relatório devem aparecer na janela "Concluído"

Não há razão para "paralelizar" a criação de relatórios, especialmente porque o mesmo servidor SQL e banco de dados são usados para criar todos os relatório

Caso isso afete a solução: acabarei precisando exibir os nomes dos relatórios (agora mostrados no console) na GUI à medida que cada relatório for criad

Primeira vez que realiza threading / subprocessamento com python, mas estou familiarizado com os dois de outros idioma

Added 20181129: O ambiente de desenvolvimento é o Python 3.6.4 de 64 bits no Win 10 usando o Eclipse Oxygen (plugin pydev). O aplicativo deve ser portátil para pelo menos linux.

A resposta mais simples parece ser o uso de threads. Apenas um encadeamento adicional é necessário (aquele que cria os relatórios). A linha afetada:

DoChosenReports()  # creates all reports (and the "Done" window)

quando alterado para:

from threading import Thread

CreateReportsThread = Thread( target = DoChosenReports )
CreateReportsThread.start()
CreateReportsThread.join()  # 20181130: line omitted in original post, comment out to unfreeze GUI 

produz com êxito os relatórios com seus nomes sendo exibidos no console à medida que são criado
No entanto, a GUI permanece congelada e a janela "Concluído" (agora invocada pelo novo thread) nunca aparece. Isso deixa o usuário no limbo, incapaz de fazer qualquer coisa e imaginando o que aconteceu, se é que aconteceu alguma coisa (é por isso que quero exibir os nomes dos arquivos na GUI à medida que são criados

BTT, Depois que os relatórios são concluídos, o segmento de criação de relatórios deve cometer suicídio silenciosamente antes (ou depois) da janela Concluído ser mostrad

Eu também tentei usar

from multiprocessing import Process

ReportCreationProcess = Process( target = DoChosenReports )
ReportCreationProcess.start()

mas que entrou em conflito com os principais programas "if (__name__ == '__main__):'" test.

Added 20181129: Acabei de descobrir o método de widget universal "waitvariable" (consultehttp: //infohost.nmt.edu/tcc/help/pubs/tkinter/web/universal.htm). A idéia básica é iniciar o código de criação de relatório como um encadeamento permanente (daemon?) Controlado por esse método (com a execução controlada pelo botão "Fazer relatórios" na GUI).

De pesquisa na web, eu sei que todas as ações do tkinter devem ser feitas no thread principal (pai), o que significa que devo mover a janela "Concluído" para esse segment
Também preciso dessa janela para exibir alguns dados (três strings) recebidos do thread "filho". Estou pensando em usar globals no nível de aplicativo como semáforos (gravados apenas pelo thread de criação de relatório e lidos apenas pelo programa principal) para passar os dados. Estou ciente de que isso pode ser arriscado com mais de dois threads, mas fazer mais alguma coisa (por exemplo, usando filas?) Para minha situação simples parece exagero.

Para resumir: Qual é a maneira mais fácil de permitir ao usuário manipular (mover, redimensionar, minimizar etc.) a janela principal de um aplicativo enquanto a janela estiver congelada por qualquer motivo. Em outras palavras, o O / S, não o tkinter, deve controlar o quadro (fora) da janela principa
resposta precisa funcionar no python 3.2.2+ de uma forma multiplataforma (pelo menos no Windows e no linu