Quem programa em Python provavelmente já precisou fazer alguma coisa com threads. Contudo quando estamos trabalhando com PyQT há alguns incovenientes em utilizar as threads da API do Python, principalmente quando temos interfaces gráficas. Recentemente tive problemas para fazer uma função que executasse determinada ação após um tempo pré-definido em segundos. Pois quando enquanto a thread não terminasse sua execução a janela gráfica não aparecia.  Encontrei duas maneiras para solucionar,  a primeira utilizando QThread e uma muito mais simples usando QTimer,  fica o registro das duas maneiras:

from PyQt4 import *
from PyQt4.QtCore import *

class MyTimer(QThread):
	def __init__(self,parent = None):
		QThread.__init__(self,parent)

	def run(self):
		while 1:
		# a cada 'self.tempo' segundos o sinal é emitido e
                  nós tratamos na outra classe. Exemplo:
			self.emit(SIGNAL("sinal_atualiza()"))
			self.sleep(self.tempo)

	def Timer(self,t=5):
		self.tempo = t
		self.start()

Depois, na sua classe basta que gerencia a interface gráfica, basta instanciar o objeto e tratar os sinais definidos em MyTimer(), você pode definir quantos sinais forem necessários:

	  self.timer = MyTimer()
	  self.timer.Timer(3) # 3 segundos

	  self.connect(self.timer,
                       QtCore.SIGNAL("sinal_stualiza()"),
                       self.atualiza)
	  # caso seja necessario executar algo após o termino da
          # therad (não é o caso do exemplo acima que o while
          # "trava" na função run()
	  self.connect(self.timer,
                       QtCore.SIGNAL("finished()"),
                       self.finaliza)

Contudo existe uma maneira muito mais fácil de fazer um timer utilizando PyQT, usando a QTimer

	self.timer = QtCore.QTimer()

	self.connect(self.timer,
                     QtCore.SIGNAL("timeout()"),
                     self.atualiza)

        self.timer.start(3000) # tempo em milisegundos

Listando informações sobre os módulos carregados

Para acessar rapidamente, via terminal, digite:

git clone git://github.com/maluta/qmodinfo.git

Caso não tenha o git instalado, acesse o endereço abaixo e clique em download para o tarball ou zip.

http://github.com/maluta/qmodinfo/tree/master

Esse post irá apresentar alguns processos de desenvolvimento utilizando PyQt através da construção de um aplicativo simples e sua evolução. Algumas dicas como utilizar o designer para fazer as telas e layouts e integrá-lo no seu código-fonte, o casamento com expressões regulares, sinais, widgets gráficos (lineEdits, labels, comboBox, etc), arquivos, processos, strings…

Todo programa começa com uma idéia, certo? A idéia que eu tive para esse exemplo foi a utilização das variáveis globais no Linux e em especial a distribuição Gentoo, que utilizo no meu desktop. Procurando na documentação encontrei a informação necessária, da qual eu traduzi a definição:

O que é uma variável de ambiente?

Um variável de ambiente contém informações usadas por uma ou mais aplicações. Muitos usuários (e especialmente aqueles novos no Linux) tem dificuldade em na sua configuração e utilização. Contudo, aprender a usar os conceitos básicos das variáveis de ambiente pode facilitar a vida em muitos casos, principalmente na mudança de configurações de programas.

Primeira idéia:

Fazer um programa para ver as variáveis de ambiente citadas

O tutorial cita as seguintes variáveis globais: PATH, ROOTPATH, LDPATH, MANPATH, INFODIR, PAGER, KDEDIRS, CONFIG_PROTECT, CONFIG_PROTECT_MASK, EDITOR. A idéia foi fazer um programa gráfico para facilitar ao usuário iniciante entender o que significa as variáveis no seu sistema. Então o programa, inicialmente deverá:

1. Mostrar as variáveis globais mais utilizadas

2. Apresentar o significado de cada variável quando o usuário passasse o cursor do mouse em cima da palavra.

Para facilitar a vida, todos as telas serão feitas no Qt Designer, pois é mais fácil criá-las e arrumar o layout. A receita é bem simples, vamos imaginar que seu arquivo (widget, dialog, etc) no designer chame form.ui. Utilizaremos o utilitário pyuic4 para convertê-lo em código Python.

#> pyuic4 form.ui -o ui_form.py

O começo do arquivo ficará semelhante a este:

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'form.ui'
#
# Created: Sun Feb 8 15:35:23 2008
#      by: PyQt4 UI code generator 4.3.1
#
# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

class Ui_Tela(object):
def setupUi(self, Tela):
Tela.setObjectName("Tela")

Depois, no código-fonte, iremos importar (ou herdar) a classe Ui_Tela onde Tela é um nome qualquer que eu escolhi. Nos outros exemplos chamarei o widget de form, logo a classe será Ui_Form.

import sys, re, os, string
from PyQt4 import QtCore, QtGui
from ui_form import Ui_Tela

class QEnvApp(QtGui.QDialog,Ui_Tela):
def __init__(self):
QtGui.QDialog.__init__(self)
self.setupUi(self)

# O CÓDIGO-FONTE AQUI

if __name__ == '__main__':

app = QtGui.QApplication(sys.argv)
dialog = QEnvApp()
dialog.show()
sys.exit(app.exec_())

Podemos pensar a primeira maneira de fazer isso com comandos já conhecidos do bash como: echo $NOME_DA_VARIÁVEL

def getEnv(self):

self.pathEdit.setText((os.popen("echo $PATH")).readline())
self.rootpathEdit.setText((os.popen("echo $ROOTPATH")).readline())
self.ldpathEdit.setText((os.popen("echo $LD_PATH")).readline())

Ou então, fazer de uma maneira mais portável:

def getEnv(self):

self.pathEdit.setText(os.environ['PATH'])
self.rootpathEdit.setText(os.environ['ROOTPATH'])
self.ldpathEdit.setText(os.environ['LD_PATH'])

Segunda Idéia

Mostrar TODAS as variáveis do sistema

Da primeira idéia surgiram dois incovenientes, primeiro que o texto contido nas variáveis excedia o tamanho da área reservada, e segundo que não mostrava TODAS as variáveis de ambiente setadas. Como são muitas variáveis, achei melhor organizá-las em uma comboBox e utilizar uma caixa de texto.

Dois detalhes são interessantes, a primeira é referente a maneira de filtrar o nome das variáveis, abaixo a função que pega a saída do comando export e através do filtro de uma expressão regular obtém os nomes das variáveis:

def getEnvNames(self):
p = os.popen("export")
while 1:
line = QtCore.QString(p.readline())
if not line: break
sline = line.split(QtCore.QRegExp("[^A-Z_]+"))
self.comboBox.insertItem(0,sline[1])

Também podemos escrever o código acima de uma maneira mais elegante, tornado-o mais portável, suponha que você rode seu script no Windows:

def getEnvNames(self):
for param in os.environ.keys():
self.comboBox.insertItem(0,param)

O outro detalhe, para evitar erros como “TypeError: popen() argument 1 must be string, not QString” é necessário fazer uma conversão do tipo QString para o tipo string. Escolhi converter utilizando o codec unicode_escape pois transforma a string em um formato compatível com o código-fonte, entretanto há uma lista de codecs disponíveis.

def showEnv(self, _index):

var =  unicode(self.comboBox.currentText(), 'unicode_escape')
p = os.popen( "echo $" + var )
self.textEdit.setText(p.readline())

Terceira Idéia

Um pouco de interação…

Até o momento o programa não dá possibilidade ao usuário de alterar e gravar o conteúdo de alguma variável, iremos fazer isso:

Lembrando de estabelecer as conexões dos widgets:

def makeconnections(self):
self.connect(self.comboBox, QtCore.SIGNAL('activated(int)'), self.showEnv)
self.connect(self.salvarButton, QtCore.SIGNAL('clicked()'), self.salvar )
self.connect(self.salvarpermanenteButton, QtCore.SIGNAL('clicked()'), self.salvarPermanentemente )

O botão Salvar grava o conteúdo na variável no ambiente de execução do programa, portanto se você fechar o programa e ver o estado da variável verá que nada foi alterado. Para ver o resultado, descomente, na função salvar do script as seguintes linhas:

#for param in os.environ.keys():
#print "%20s %s" % (param,os.environ[param])

Já o botão Salvar Permanentemente grava o conteúdo no arquivo ~/.bashrc, para que todas as novas instâncias mantenham o conteúdo alterado. Será salvo no final do arquivo.

def salvarPermanentemente(self):

path = os.environ['HOME'] + "/.bashrc"

var = unicode(self.comboBox.currentText(), 'unicode_escape')

value = unicode(self.textEdit.toPlainText(), 'unicode_escape')

f=file(path, 'a')
f.write("export " + var + "=" + value )
f.close()

Os três exemplos estão no arquivo abaixo

*** Download (tar.gz) ***

Conclusão

Acredito que um principais objetivos das linguagens interpretadas é proporcionar a construção de aplicativos de forma mais rápida se comparado com outras linguagens como Java ou C++. Pode-se desenvolver desde pequenos utilitários até automatizar grandes processos: como backup, configuração, comunicação, interfaces, front-ends; tudo aliado a vantagem da independência em relação ao Sistema Operacional (exceto em casos específicos, como editar o arquivo .bashrc). Alguns exemplos de projetos, como o PyQemu – uma interface em Python para o Qemu – refletem as possibilidades da linguagem e sua utilização nos mais diversos segmentos.

Referências:

http://docs.python.org/lib/lib.html

http://wiki.python.org/moin/PyQt4

http://www.diotavelli.net/PyQtWiki