[pyar] Alguien ha trabajado con QThread de PyQt?

Alberto Perez ksian1685 en gmail.com
Jue Jul 16 11:33:07 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 ]
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
>
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.python.org.ar/pipermail/pyar/attachments/20150716/33ee7599/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