[pyar] Alguien ha trabajado con QThread de PyQt?

Martin Alderete malderete en gmail.com
Jue Jul 16 17:48:05 ART 2015
Mensaje anterior: [pyar] Alguien ha trabajado con QThread de PyQt?
Próximo mensaje: [pyar] Alguien ha trabajado con QThread de PyQt?
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
De nada che!

mmmm... Si queres mandar como parametro un objeto no primitivo tenes que
hacer algo como

data_to_emit = {'data': aca_los_datos}

emit(SIGNAL("tuSignalName(PyQt_PyObject)"), data)
fijate que ahi  en la firma de "tuSignalName" dice que envia un
"PyQt_PyObject" eso quiere decir que es un objeto de python no indica
cual...

Usando pyqtSignal como te dije en el mail anterior podes hacer algo como lo
que sigue (si mal no recuerdo)

tuSignalName = pyqtSignal(dict)

tuSignalName.emit({'data': "hola"})


"connect()" sirve para hacer algo cuando ocurre un evento, en tu caso
deberias tener algo como:
self.c.comuni.connect(self._set_message)

en la clase que hizo el connect tener:
def _set_message(self, data_from_emit):
    txt = data_from_emit['data']
    self.mensa.setPlainText(txt)


Entonces cuando se hace emit() de la signal "comuni" (en este caso) se
llama al metodo "_set_message", porque en el connect() le indicaste eso, y
le llega como parametro lo que enviaron en emit()

Te recomiendo que mires la doc de pyqt sobre todo en Signals & slots para
poder entender bien como funciona :)

Espero que te sirva.

saludos!





2015-07-16 17:25 GMT-03:00 Alberto Perez <ksian1685 en gmail.com>:

> Gracias Martin, ya aprendí algo nuevo:
> self.c=comunicate()
>
>         #self.recibir()
>         self.c.comuni.connect(lambda: self.mensa.setPlainText(data))
>  def recibir(self):
>         self.data=None
>         s=socket(AF_INET,SOCK_STREAM)
>         s.bind(("127.0.0.1", 1685))
>         s.listen(10)
>         (clientsocket,direct) = s.accept()
>
>         while 1:
>             self.data=clientsocket.recv(1024)
>             #QTextEdit.setPlainText(data)
>             self.c.comuni.emit(SIGNAL("setPlainText()"),{"data":
> self.data})
>             #self.connect(QWid.mensa.setPlainText(data))
>             #self.newDataSignal.emit(data)
>             #newDataSignal.emit(data)
>             #self.setPlainText(data)
>         clientsocket.close()
>
>         ahora estoy investigando como pasar un argumento desde emit a
> connect
>
> El 16 de julio de 2015, 12:27, Martin Alderete <malderete en gmail.com>
> escribió:
>
>> Buenas!
>> Como va?
>>
>> Generalmente para que un QThread "se comunique" con el Main-thread (la
>> UI) podes emitir "señales" (signals de QT) desde el thread porque QThread
>> hereda de QObject y manejas la señal desde el main thread.
>>
>> Ejemplo:
>>
>> desde el QThread haces algo como:
>>
>> from PyQt4.QtCore import pyqtSignal
>>
>>
>>
>> self.newDataSignal = pyqtSignal(str)
>> #mas codigo
>> #emitis la señal porque tenes datos
>> self.newDataSignal.emit(data)
>>
>> desde el que llama al QThread algo como:
>>
>> self.thread = TuQThread()
>> # conectas la señal
>> self.thread.newDataSignal.connect(self._on_new_data)
>> #lanzas el thread
>> self.start()
>>
>>
>> def _on_new_data(self, data):
>>      #aca procesas los datos
>>      #mostrarlos en algun widget o lo que desees
>>
>>
>>
>> Ojo! es un ejemplo sin probar solo borrador para que veas la idea....
>>
>> Mas info podes buscar en la doc de QT:
>> http://doc.qt.io/qt-4.8/signalsandslots.html
>>
>> Espero te sirva
>>
>> saludos!
>>
>>
>>
>>
>>
>>
>> 2015-07-16 11:33 GMT-03:00 Alberto Perez <ksian1685 en gmail.com>:
>>
>>> Quizás alguno de ustedes pueda ayudarme. Resulta que tengo que presentar
>>> un TP para un final. La idea que se me ocurrió en un principio era bastante
>>> fácil: un chat en python, pero tuve la pésima idea de agregarle un entorno
>>> grafico para hacerlo más vistoso. Y ahí está el asunto de este mensaje:
>>> cuando lanzo el hilo de la siguiente forma :
>>>
>>> e=threading.Thread(target=mensa.escuchar)
>>>
>>> e.start()
>>>
>>> me tira un error porque debería ser QThread. Ahora cree la clase Thread
>>> para manejar Qthread, pero me tira error porque no puedo acceder a
>>> qtextedit desde Thread. Mi error parece ser un tema de jerarquías
>>>
>>>
>>>
>>> import *threading*
>>>
>>> import *sys*
>>>
>>> from *socket **import** **
>>>
>>> from *PyQt4.QtGui **import** **
>>>
>>> from PyQt4 import *QtCore*
>>>
>>> from *PyQt4.QtCore **import** **
>>>
>>> from Tkinter import *Widget*
>>>
>>> from time import *sleep*
>>>
>>>
>>>
>>> class *QWid*(QWidget):
>>>
>>>     def *__init__*(*self*):
>>>
>>>         super(QWid, *self*).__init__()
>>>
>>>         *self*.setWindowTitle(*"Cliente"*)
>>>
>>>         #self.setWindowTitle("*Cliente*")
>>>
>>>         #self.recibido=QTextEdit()
>>>
>>>         boton= QPushButton (*"mandar mesaje"*, *self*)
>>>
>>>
>>>
>>>         mensa=QTextEdit()
>>>
>>>         layout_horizontal=QHBoxLayout(*self*)
>>>
>>>         layout_horizontal.addWidget(mensa)
>>>
>>>         layout_horizontal.addWidget(boton)
>>>
>>>
>>>
>>>         #layout_horizontal.addWidget(self.recibido)
>>>
>>>
>>>
>>>         #e=threading.Thread(target=mensa.escuchar)
>>>
>>>         #e.start()
>>>
>>>
>>>
>>>         *self*.thread = Thread()
>>>
>>>         *self*.thread.start()
>>>
>>>
>>>
>>>         #QThread.currentThread(mensa.escuchar())
>>>
>>>
>>>
>>>         #boton.clicked.connect(mensa.escuchar)
>>>
>>>
>>>
>>>         *self*.resize(800,600)
>>>
>>>         #boton.clicked.connect(self.escribir)
>>>
>>>         #mensa.escuchar()
>>>
>>>
>>>
>>>     def *escribir*(*self*):
>>>
>>>         s = socket(AF_INET, SOCK_STREAM)
>>>
>>>         s.connect((*"127.0.0.1"*, 1685))
>>>
>>>
>>>
>>>         #*datos*="*prueba*"
>>>
>>>         datos=*self*.recibido.toPlainText()
>>>
>>>
>>>
>>>         s.send(datos)
>>>
>>>         s.close()
>>>
>>>
>>>
>>> class *Thread*(QThread):
>>>
>>>     def *__init__*(*self*):
>>>
>>>         QThread.__init__(*self*)
>>>
>>>
>>>
>>>     def *run*(*self*):
>>>
>>>
>>>
>>>         data=None
>>>
>>>         s=socket(AF_INET,SOCK_STREAM)
>>>
>>>         s.bind((*"127.0.0.1"*, 1685))
>>>
>>>         s.listen(10)
>>>
>>>         (clientsocket,*direct*) = s.accept()
>>>
>>>
>>>
>>>         while 1:
>>>
>>>             data=clientsocket.recv(1024)
>>>
>>>             #QTextEdit.setPlainText(data)
>>>
>>>             *self*.setPlainText(data)
>>>
>>>         clientsocket.close()
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> #class QTextEditMod(QTextEdit):
>>>
>>> #    *def* __init__(self):
>>>
>>> #        super(QTextEditMod, self).__init__()
>>>
>>>
>>>
>>>
>>>
>>> #    *def* *escuchar*(self):
>>>
>>> #        data=None
>>>
>>> #        s=socket(AF_INET,SOCK_STREAM)
>>>
>>> #        s.bind(("127.0.0.1", 1685))
>>>
>>> #        s.listen(10)
>>>
>>> #        (*clientsocket*,direct) = s.accept()
>>>
>>> #        while 1:
>>>
>>> #            data=clientsocket.recv(1024)
>>>
>>> #            self.setPlainText(data)
>>>
>>> #        clientsocket.close()
>>>
>>>
>>>
>>>
>>>
>>> if __name__ == *'__main__'*:
>>>
>>>     app= QApplication(sys.argv)
>>>
>>>     w= QWid()
>>>
>>>     w.show()
>>>
>>>     sys.exit(app.exec_())
>>>
>>>
>>> Alguien tiene idea de cómo arreglarlo. O una guia de python para
>>> entender como es la comunicacion entre procesos QThread?
>>>
>>> El 11 de julio de 2015, 16:39, Enrique Alejandro Villafañe <
>>> villafane.enrique en gmail.com> escribió:
>>>
>>>> Bueno he estado leyendo y hasta el momento con su ayuda logre migrar de
>>>> Threads de Python a QThread, ya estoy creando poco a poco la interfaz. Si
>>>> me trabo en algun paso les estare avisando a ver si me pueden ayudar, en
>>>> cuanto el proyecto este terminado se los hago llegar por aca, es un
>>>> proyecto personal asi que me gustaria compartirlo a ver si hay algo que
>>>> mejorar en el codigo que me puedan recomendar, que seguramente que si
>>>> porque apenas es mi primera aplicacion.
>>>>
>>>> Gracias
>>>>
>>>> El 11 de julio de 2015, 13:14, Sebastián Seba <ssebastianj en gmail.com>
>>>> escribió:
>>>>
>>>>> El 10 de julio de 2015, 21:38, Gabriel Acosta <
>>>>> acostadariogabriel en gmail.com> escribió:
>>>>>
>>>>>> El funcionamiento es básicamente el mismo a thread de Python, con la
>>>>>> diferencia que con QThread al heredar de QObject, podes emitir, conectar
>>>>>> señales.
>>>>>>
>>>>>> class Thread(QThread):
>>>>>>     def __init__(self):
>>>>>>         QThread.__init__(self)
>>>>>>
>>>>>>     def run(self):
>>>>>>         pass
>>>>>>
>>>>>> El método run() se ejecuta cuando inicias el thread:
>>>>>>
>>>>>> self.thread = Thread()
>>>>>> self.thread.start()
>>>>>>
>>>>>> Saludos.
>>>>>>
>>>>>> Gabriel Acosta
>>>>>> http://centaurialpha.github.io
>>>>>> On Jul 10, 2015 8:27 PM, "Enrique Alejandro Villafañe" <
>>>>>> villafane.enrique en gmail.com> wrote:
>>>>>>
>>>>>>> Nuevamente escribo con algo referente a las interfaces graficas, ya
>>>>>>> me he estudiado el uso de PyQt y gracias a los tutoriales de Gabriel Acosta
>>>>>>> he entendido el funcionamiento basico de los widgets y las funciones, pero
>>>>>>> resulta que para mi necesidad la cosa va mas complicada de lo que parecia,
>>>>>>> yo tengo una aplicacion que se encarga de escuchar por puerto serial unas
>>>>>>> tramas, mi aplicacion gracias al modulo threads de python maneja varios
>>>>>>> puertos al mismo tiempo y hasta ahi todo el proceso perfecto, el problema
>>>>>>> es que ahora para hacerle interfaz grafica mi idea es sencilla, una ventana
>>>>>>> con algunos tabs y dentro de los tabs unas tablas, de acuerdo a la cantidad
>>>>>>> de puertos que tenga en un txt que ya existe y funciona, deberian crearse
>>>>>>> la cantidad de tabs y sus tablas internas para insertar alli de modo visual
>>>>>>> lo que va llegando en cada puerto por separado en cada tab. Segun he estado
>>>>>>> leyendo para eso tengo que olvidarme del modulo thread de python y trabajar
>>>>>>> con el modulo Qthread de PyQt del que solo consegui documentacion en ingles
>>>>>>> y realmente no soy muy bueno con ello, aparte de que es mi primera
>>>>>>> aplicacion "compleja" real en la que trabajo y no estoy muy diestro. Si
>>>>>>> alguien ha utilizado este modulo y me puede explicar como funciona estare
>>>>>>> muy agradecido.
>>>>>>>
>>>>>>> Saludos
>>>>>>>
>>>>>>> --
>>>>>>> Enrique A Villafañe
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> _______________________________________________
>>>>>>> pyar mailing list pyar en python.org.ar
>>>>>>> http://listas.python.org.ar/listinfo/pyar
>>>>>>>
>>>>>>> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>>>>>>>
>>>>>>> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre
>>>>>>> de Argentina - http://www.usla.org.ar
>>>>>>>
>>>>>>
>>>>>> _______________________________________________
>>>>>> pyar mailing list pyar en python.org.ar
>>>>>> http://listas.python.org.ar/listinfo/pyar
>>>>>>
>>>>>> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>>>>>>
>>>>>> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre
>>>>>> de Argentina - http://www.usla.org.ar
>>>>>>
>>>>>
>>>>> Yo hace unos años hice un proyecto similar para un cliente, donde una
>>>>> aplicación en Python (y con UI hecha en PyQt) tenía que leer y escribir
>>>>> tramas en el puerto serie. No puedo mostrar código pero recuerdo que en ese
>>>>> entonces no utilicé QThread sino Threading de Python solamente y no tuve
>>>>> problemas en actualizar la UI. El tema está en utilizar Queue adecuadamente
>>>>> y mínimamente me sirvió.
>>>>>
>>>>> Así como comenta Gabriel, las interfaces de QThread de PyQt son
>>>>> bastante similares (sino iguales) a las de Thread de Python pero con
>>>>> agregados copados como las señales. Por ejemplo, una porción de código que
>>>>> encontré y modifiqué era algo como:
>>>>>
>>>>> class CalcularWorker(QtCore.QObject):
>>>>>     def __init__(self):
>>>>>         pass
>>>>>
>>>>> class MainWindow(QtGui.QMainWindow):
>>>>>     ...
>>>>>
>>>>>     calcular_thread = QtCore.QThread(self)                    #
>>>>> Instanciar un QThread
>>>>>     calcular_worker = CalcularWorker(1, 2, 3)                 #
>>>>> Instanciar un worker para que realice el cálculo heavy
>>>>>     calcular_worker.moveToThread(calcular_thread)      # Mover cálculo
>>>>> heavy al thread
>>>>>
>>>>>    calcular_thread.finished.connect(lambda:
>>>>> self.hacer_algo_al_terminar())    # Al finalizar ejecución del thread,
>>>>> hacer algo.
>>>>>    calcular_thread.start()     # Ejecutar thread.
>>>>>
>>>>>
>>>>> Dependiendo del caso, fijate si te conviene crear una nueva clase que
>>>>> herede de QThread y en esa clase implementar el método "run" o simplemente
>>>>> instanciar un QThread y pasarle como argumento la función.
>>>>>
>>>>> Saludos.
>>>>>
>>>>> --
>>>>>
>>>>> *Sebastián J. Seba*
>>>>>
>>>>> _______________________________________________
>>>>> pyar mailing list pyar en python.org.ar
>>>>> http://listas.python.org.ar/listinfo/pyar
>>>>>
>>>>> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>>>>>
>>>>> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre de
>>>>> Argentina - http://www.usla.org.ar
>>>>>
>>>>
>>>>
>>>>
>>>> --
>>>> Enrique A Villafañe
>>>>
>>>> *Telefonos de Contacto*
>>>>
>>>> Celular : +58 412 5151603
>>>> Oficina: +58 273 5325224 - +58 273 5321592 - +58 273 5325527
>>>>
>>>> _______________________________________________
>>>> pyar mailing list pyar en python.org.ar
>>>> http://listas.python.org.ar/listinfo/pyar
>>>>
>>>> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>>>>
>>>> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre de
>>>> Argentina - http://www.usla.org.ar
>>>>
>>>
>>>
>>> _______________________________________________
>>> pyar mailing list pyar en python.org.ar
>>> http://listas.python.org.ar/listinfo/pyar
>>>
>>> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>>>
>>> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre de
>>> Argentina - http://www.usla.org.ar
>>>
>>
>>
>>
>> --
>> Martin Alderete
>>
>> _______________________________________________
>> pyar mailing list pyar en python.org.ar
>> http://listas.python.org.ar/listinfo/pyar
>>
>> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>>
>> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre de
>> Argentina - http://www.usla.org.ar
>>
>
>
> _______________________________________________
> pyar mailing list pyar en python.org.ar
> http://listas.python.org.ar/listinfo/pyar
>
> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>
> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre de
> Argentina - http://www.usla.org.ar
>



-- 
Martin Alderete
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.python.org.ar/pipermail/pyar/attachments/20150716/cbec1c12/attachment-0001.html>
Mensaje anterior: [pyar] Alguien ha trabajado con QThread de PyQt?
Próximo mensaje: [pyar] Alguien ha trabajado con QThread de PyQt?
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the pyar mailing list