elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recopilación Tutoriales y Manuales Hacking, Seguridad, Privacidad, Hardware, etc


  Mostrar Temas
Páginas: 1 2 3 [4] 5 6
31  Programación / Scripting / Diferentes maneras de declarar multiples variables - JaAViEr|0x5d en: 18 Abril 2012, 06:00 am
Hola, buen día a todos !

En esta oportunidad pretendo explicar como declarar varias variables, con ánimos de reducir código (esto me fascina). En un caso utilizaré tuplas para declarar variables, en otra el comando exec() y pues como se nos ocurra. El primer ejemplo de como declarar más de una variable en una sola línea:

Código
  1. exec("%s"%"uno='Elemento 1';dos='Elemento 2'")

nos creará la variable "uno" con valor "Elemento 1" y la variables "dos" con valor "Elemento 2" , es cosa de solo añadir un:

Código
  1. print uno, dos

Otra forma podría ser:

Código
  1. # -*- coding: utf-8 -*-
  2. valores = ("Elemento 1","Elemento 2")
  3. variables = "uno,dos"
  4. exec("%s=valores"%variables)

que también utiliza exec() para llevar acabo el cometido.
Se me ocurre esto también:

Código
  1. uno, dos, tres = ("Elemento 1", "Elemento 2", "Elemento 3")
  2. print uno, dos, tres

Lo que nos crea 3 variables: uno, dos, tres.
Valores: Elemento 1, Elemento 2, Elemento 3

También usando exec() :

Código
  1. variables = ['uno="Elemento 1"','dos="Elemento 2"','tres="Elemento 3"']
  2. for i in variables:
  3.   exec(i)
  4. print uno, dos, tres
  5.  

Si queremos reducir dicho código:

Código
  1. for i in ['uno="Elemento 1"','dos="Elemento 2"','tres="Elemento 3"']:  exec(i)
  2. print uno, dos, tres

Como ven hay muchas formas de poder declarar múltiples variables en pocas
líneas :D , espero que encuentren su utilidad (:

Saludos, 0x5d!

Fuente : http://rootcodes.com/pythondiferentes-maneras-de-declarar-variables/
32  Programación / Scripting / [Código-PyQT4]Detectar campos de un formulario web - JaAViEr|0x5d en: 8 Abril 2012, 04:21 am
Hola, buen día !

Sigo con mis prácticas en Python + QT4. Posterior a esto seguiré con el tutorial que estuve escribiendo para RootCodes... En esta oportunidad he traspasado este código en consola ~> [Python]Detectar formulario y campos de un sitio web a PyQT. Así aprovechando de utilizar QTreeWidget(); Para aprender a usarlo y a la vez que ustedes vean como se usa.

Un ScreenShot de la App :



Y el Código :
Código
  1. # -*- coding: utf-8 -*-
  2. # Autor ~> JaAViEr|0x5d
  3. # Sitio Web ~> http://www.rootcodes.com
  4. # Twitter ~> @0x5d
  5.  
  6. from PyQt4 import QtCore, QtGui
  7. import sys, urllib, re
  8.  
  9. class aplica(QtGui.QWidget):
  10.   def __init__(self, parent=None):
  11.     QtGui.QWidget.__init__(self, parent)
  12.     self.setWindowTitle("Detectar campos de un formulario | 0x5d")
  13.     self.resize(510,570)
  14.     self.arbol = QtGui.QTreeWidget(self)
  15.     self.arbol.setGeometry(5,70,500,500)
  16.     self.label_url = QtGui.QLabel("URL/Host :", self).setGeometry(5,10,64,27)
  17.     self.input_url = QtGui.QLineEdit(self)
  18.     self.input_url.setGeometry(73,10,430,27)
  19.     self.boton = QtGui.QPushButton("Extraer campos del formulario",self)
  20.     self.boton.setGeometry(73,40,430,27)
  21.     self.connect(self.boton, QtCore.SIGNAL("clicked()"), self.extractor)
  22.     self.arbol.headerItem().setText(0,"Campos")
  23.  
  24.   def extractor(self):
  25.     var = urllib.urlopen(str(self.input_url.text())).read()
  26.     datos_r = []
  27.     for campos in re.findall("<input (.*)>",var):
  28.       if "name" in campos.lower():
  29. 	for cam in campos.split():
  30. 	  if re.findall("name=(.*)",cam):
  31. 	    datos_r.append(cam.replace('"',""))
  32.     #print "URL a enviar POST:",url_enviar.replace(">","")
  33.     for x,y in enumerate(datos_r):
  34.       exec("primer_%s = QtGui.QTreeWidgetItem(self.arbol)"%x)
  35.       exec("self.arbol.topLevelItem(%s).setText(0, \"%s\")"%(x,y.replace("name=","")))
  36.  
  37. app = QtGui.QApplication(sys.argv)
  38. form = aplica()
  39. form.show()
  40. app.exec_()
  41.  

Fuente: http://rootcodes.com/pyqt4detectar-campos-de-un-formulario-web/

Saludos, Javier.
33  Programación / Scripting / [Código-PyQT4]Binario a decimal y su inverso - JaAViEr | 0x5d en: 6 Abril 2012, 23:39 pm
Hola a todos !

Como le he vuelto a dar la vida a mi PC. Instalé el Debian de nuevo, no podía faltar instalar el amado QT4. Así que me propuse como práctica crear este mismo código Consola ~> [Python]Decimal a binario y su invero, que por cierto también pasé a la web ~> Binary Converter Online. Esta vez en PyQT4 primero les dejo el screenshot de como se ve:


Y Su código :
Código
  1. # -*- coding: utf-8 -*-
  2. # Autor : 0x5d ~> JaAViEr
  3. # Sitio Web ~> www.rootcodes.com
  4. # Twitter ~> @0x5d
  5.  
  6. from PyQt4 import QtGui, QtCore
  7. import sys
  8.  
  9. class testeo(QtGui.QWidget):
  10.   def __init__(self, parent=None):
  11.     QtGui.QWidget.__init__(self, parent)
  12.     self.setWindowTitle("Bin to Dec | 0x5d")
  13.     self.label_binario = QtGui.QLabel("Binario :", self).setGeometry(2,15,59,17)
  14.     self.input_binario = QtGui.QLineEdit(self)
  15.     self.input_binario.setGeometry(60,10,230,27)
  16.     self.label_resultado = QtGui.QLabel("Resultado :", self).setGeometry(2,50,80,17)
  17.     self.input_salida = QtGui.QLineEdit(self)
  18.     self.input_salida.setGeometry(80,43,210,27)
  19.     self.input_salida.setReadOnly(True)
  20.     self.boton_limpiar = QtGui.QPushButton("Limpiar campos", self)
  21.     self.boton_limpiar.setGeometry(1,75,140,27)
  22.     self.boton_convertir = QtGui.QPushButton("Convertir", self)
  23.     self.boton_convertir.setGeometry(145,75,140,27)
  24.     self.connect(self.boton_limpiar, QtCore.SIGNAL("clicked()"), self.clear_inputs)
  25.     self.connect(self.boton_convertir, QtCore.SIGNAL("clicked()"), self.conversor)
  26.  
  27.   def clear_inputs(self):
  28.     self.input_binario.setText("")
  29.     self.input_salida.setText("")
  30.  
  31.   def conversor(self):
  32.     numero = str(self.input_binario.text())
  33.     t = 0
  34.     for i,h in zip(numero[::-1],range(0,len(numero))): t+=int(i)*2**int(h)
  35.     self.input_salida.setText(str(t))
  36.  
  37. app = QtGui.QApplication(sys.argv)
  38. form = testeo()
  39. form.show()
  40. app.exec_()
  41.  
Y Decimal a Binario:

Código ~>:
Código
  1. # -*- coding: utf-8 -*-
  2. # Autor : 0x5d ~> JaAViEr
  3. # Sitio Web ~> www.rootcodes.com
  4. # Twitter ~> @0x5d
  5.  
  6. from PyQt4 import QtGui, QtCore
  7. import sys
  8.  
  9. class testeo(QtGui.QWidget):
  10.   def __init__(self, parent=None):
  11.     QtGui.QWidget.__init__(self, parent)
  12.     self.setWindowTitle("Dec to Bin | 0x5d")
  13.     self.label_binario = QtGui.QLabel("Decimal:", self).setGeometry(2,15,59,17)
  14.     self.input_binario = QtGui.QLineEdit(self)
  15.     self.input_binario.setGeometry(60,10,230,27)
  16.     self.label_resultado = QtGui.QLabel("Resultado :", self).setGeometry(2,50,80,17)
  17.     self.input_salida = QtGui.QLineEdit(self)
  18.     self.input_salida.setGeometry(80,43,210,27)
  19.     self.input_salida.setReadOnly(True)
  20.     self.boton_limpiar = QtGui.QPushButton("Limpiar campos", self)
  21.     self.boton_limpiar.setGeometry(1,75,140,27)
  22.     self.boton_convertir = QtGui.QPushButton("Convertir", self)
  23.     self.boton_convertir.setGeometry(145,75,140,27)
  24.     self.connect(self.boton_limpiar, QtCore.SIGNAL("clicked()"), self.clear_inputs)
  25.     self.connect(self.boton_convertir, QtCore.SIGNAL("clicked()"), self.conversor)
  26.  
  27.   def clear_inputs(self):
  28.     self.input_binario.setText("")
  29.     self.input_salida.setText("")
  30.  
  31.   def conversor(self):
  32.     resto = []
  33.     nuevo = [int(self.input_binario.text())]
  34.     while nuevo[-1]!=0:
  35.       resto.append(nuevo[-1]%2)
  36.       nuevo.append(nuevo[-1]/2)
  37.     s = ""
  38.     for i in resto[::-1]: s+="%s"%i
  39.     self.input_salida.setText(str(s))
  40.  
  41. app = QtGui.QApplication(sys.argv)
  42. form = testeo()
  43. form.show()
  44. app.exec_()
  45.  

Fuente : http://rootcodes.com/pyqt4binario-a-decimal-y-su-inverso/

Saludos, Javier.
34  Programación / Scripting / [Tutorial]Aprendiendo PyQT4 [Parte4]- JaAViEr (0x5d) en: 13 Febrero 2012, 02:27 am
Hola nuevamente !

 En la [Parte3] dejé pendiente hablar sobre como obtener los datos de un QLineEdit(), voy a ir directo al grano :P.

 Pondré un ejemplo sencillo, tenemos el QLineEdit():
Código
  1. self.input_datos = QtGui.QLineEdit(self)
Entonces para obtener lo que ingresamos, usamos la propiedad .text() acompañada de un str() para que no devuelva el objeto y si el valor:
Código
  1. variable = str(self.input_datos.text())

  Entonces solo bastaría poner dicha línea en la función del botón(self.connect):
Código
  1. def funcion(self):
  2.   recibo_datos = str(self.input_datos.text())
  3.  
Y con ello ya tendremos en nuestras manos el valor del QLineEdit() en la variable. Ahora con ella podemos hacer lo mismo que hacemos en nuestros códigos Python normales, a nuestro antojo.

 Pero como quedó pendiente en la pasada parte sobre utilizar el valor del QLineEdit() en el QLabel(), con lo que hemos visto ya deberíamos saber hacerlo :D, de todas formas dejaré el código con comentarios :
Código
  1. # -*- coding: utf-8 -*-
  2. from PyQt4 import QtCore, QtGui
  3. import sys
  4.  
  5. class Mi_Programa(QtGui.QWidget):
  6.  
  7.   def __init__(self, parent=None):
  8.  
  9.     QtGui.QWidget.__init__(self, parent)
  10.     self.resize(200,134) 
  11.     #Creamos los Labels,label_mensaje "Mensaje:", label_resultado el mensaje de "Resultado:"
  12.     #Y el tercero mostrará el texto ingresado.
  13.     self.label_mensaje = QtGui.QLabel("Mensaje:", self)
  14.     self.label_mensaje.setGeometry(3,14,59,17)
  15.     self.label_resultado = QtGui.QLabel("Resultado:", self)
  16.     self.label_resultado.setGeometry(5,80,71,17)
  17.     self.label_show = QtGui.QLabel("",self)
  18.     self.label_show.setGeometry(80,80,111,17)
  19.     #Creamos el QLineEdit para pedir datos 
  20.     self.input_datos = QtGui.QLineEdit(self)
  21.     self.input_datos.setGeometry(60,10,113,27)
  22.     #Creamos el Boton
  23.     self.mi_boton = QtGui.QPushButton("Dame Clic", self) 
  24.     self.mi_boton.setGeometry(60,40,92,27)
  25.     #Le damos función al botón
  26.     self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.show_message)
  27.  
  28.   def show_message(self):
  29.     mensaje = str(self.input_datos.text())
  30.     self.label_show.setText(mensaje)
  31. aplicacion = QtGui.QApplication(sys.argv)
  32. formulario = Mi_Programa() 
  33. formulario.show() 
  34. aplicacion.exec_() 
  35.  
Explico un poco:
Al dar clic en el botón, llamamos a la función show_message() en la cual obtendremos el dato de self.input_datos, posteriormente guardamos el valor en la variable mensaje y como ya vimos, usamos setText(mensaje) para darle el nuevo valor al QLabel().

  Supongo que ya no hay temas pendientes con QLineEdit, QLabel, QPushButton :P, veamos el uso de otros Widgets, el siguiente es QPlainTextEdit().

  Como dice su nombre, es para insertar un texto plano, a diferencia del QLineEdit, este es multilíneas.

 La manera de utilización es la siguiente :
Código
  1. self.texto_plano = QtGui.QPlainTextEdit("", self)
Como ya sabemos, usamos la propiedad setGeometry() para dar posición, ancho y altura.
 
  Para obtener los datos que se insertan en dicho widget, usaremos la propiedad toPlainText(), que es el equivalente al .text() del QLineEdit.

  Para insertar datos en un QPlainTextEdit(), debemos usar setPlainText('Msj').

Un pequeño ejemplo de lo que he escrito en código :
Código
  1. # -*- coding: utf-8 -*-
  2. from PyQt4 import QtCore, QtGui
  3. import sys
  4.  
  5. class Mi_Programa(QtGui.QWidget):
  6.  
  7.   def __init__(self, parent=None):
  8.  
  9.     QtGui.QWidget.__init__(self, parent)
  10.     self.resize(400,319) # Tamaño
  11.     #Creamos el primer PlainTextEdit que luego envía los datos al segundo
  12.     self.texto_plano = QtGui.QPlainTextEdit("", self)
  13.     self.texto_plano.setGeometry(10,10,191,271)
  14.     #Creamos el botón
  15.     self.transcribir = QtGui.QPushButton("Transcribir", self)
  16.     self.transcribir.setGeometry(10,285,95,27)
  17.     #Creamos el segundo PlainTextEdit que recibirá el primer contenido
  18.     self.nuevo_txt = QtGui.QPlainTextEdit("", self)
  19.     self.nuevo_txt.setGeometry(206,10,191,271)
  20.     #Le damos la función al botón y llamamos al def transcribe
  21.     self.connect(self.transcribir, QtCore.SIGNAL('clicked()'), self.transcribe)
  22.  
  23.   def transcribe(self):
  24.     #Obtenemos el contenido del primer QPlainTextEdit
  25.     contenido = self.texto_plano.toPlainText()
  26.     #Escribimos el contenido del primer QPlainTextEdit en el segundo
  27.     #Usando setPlainText
  28.     self.nuevo_txt.setPlainText(contenido)
  29.  
  30. aplicacion = QtGui.QApplication(sys.argv)
  31. formulario = Mi_Programa() 
  32. formulario.show() 
  33. aplicacion.exec_()


 Luego seguiré con el QTextBrowser(), que nos permite ingresar código HTML en el campo de escritura...

Fuente : http://rootcodes.com/tutorialaprendiendo-pyqt4-con-rootcodes-parte4/

Saludos, Javier.
35  Programación / Scripting / [Tutorial]Aprendiendo PyQT4 [Parte3]- JaAViEr (0x5d) en: 11 Febrero 2012, 20:21 pm
Hola ! , en la pasa ocasión quedaron pendientes un par de puntos :
  • Dar función a un botón
  • Crear un QLabel()
  • Nuestro primer Hola mundo en PyQT4

 Bien, manos a la obra, para quienes no sepan que es un Label, dejaré un Screenshot , es algo bien sencillo:


 Sencillo no ? , nos servirá para imprimir resultados por pantalla, como dije en la primera parte, como un reemplazo al print de la versión Python en Consola.

 Bueno... ¿ Y cómo uso el QLabel ?

 Nada más que esto:
Código
  1. self.mi_label = QtGui.QLabel("Mi texto", self)
  2.  
Luego pueden cambiar las coordenadas con el ya mencionado self.objeto.setGeometry() (donde objeto puede ser un QLabel, QLineEdit, etc)

  Siguiendo con algo más "útil", pasaré a explicar como dar vida a los famosos Botones.

  Para poder crear acciones al dar clic en un botón, usaremos self.connect(), pero antes de ello, debemos tener una función creada para que al dar clic, esta se ejecute...

  La sintaxis del self.connect será esta:
Código
  1. self.connect(self.mi_boton, QtCore.SIGNAL("clicked()"), self.respuesta)
Paso a explicar:
  • self.connect(self.mi_boton = Eso indica que la función self.respuesta solo será ejecutada al dar clic en el botón "self.mi_boton"
  • QtCore.SIGNAL('clicked()'), quiere decir que será ejecutado al ser clickeado
  • self.respuesta) es la función que se ejecuta al ser clickeado el botón
Osea, en nuestros programas, la única parte que debería cambiar serían self.mi_boton y self.respuesta, veamos como queda el código:
Código
  1. # -*- coding: utf-8 -*-
  2. from PyQt4 import QtCore, QtGui
  3. import sys
  4.  
  5. class Mi_Programa(QtGui.QWidget):
  6.  
  7.   def __init__(self, parent=None):
  8.  
  9.     QtGui.QWidget.__init__(self, parent)
  10.     self.resize(200,200) #Dimensiones del formulario
  11.     self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
  12.     self.mi_boton.setGeometry(10,10,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
  13.     self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.respuesta)
  14.     self.mi_label = QtGui.QLabel('', self)#Lo definimos sin texto, luego le damos un valor
  15.     self.mi_label.setGeometry(10,40,92,27)
  16.  
  17. aplicacion = QtGui.QApplication(sys.argv)
  18. formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
  19. formulario.show() # Mostramos el Formulario
  20. aplicacion.exec_() # Ejecutamos
  21.  
  Bien hasta ahí... Pero algo falta... La función respuesta !
Haremos algo sencillo, que al dar clic en el botón, nos cree un QLabel con una respuesta:
Código
  1.   def respuesta(self):
  2.     self.mi_label.setText('Gracias !')
  3.  
Pero que es eso ! ? , setText() ?
Sí, es la propiedad que usaremos para definir un texto en el QLabel(), siempre y cuando el QLabel() ya haya sido creado.

Entonces nuestro código será el siguiente, ya terminado:
Código
  1. # -*- coding: utf-8 -*-
  2. from PyQt4 import QtCore, QtGui
  3. import sys
  4.  
  5. class Mi_Programa(QtGui.QWidget):
  6.  
  7.   def __init__(self, parent=None):
  8.  
  9.     QtGui.QWidget.__init__(self, parent)
  10.     self.resize(200,200) #Dimensiones del formulario
  11.     self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
  12.     self.mi_boton.setGeometry(10,10,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
  13.     self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.respuesta)
  14.     self.mi_label = QtGui.QLabel('', self)
  15.     self.mi_label.setGeometry(10,40,92,27)
  16.  
  17.   def respuesta(self):
  18.     self.mi_label.setText('Gracias !') #Defino un texto al dar clic en self.mi_boton
  19.  
  20. aplicacion = QtGui.QApplication(sys.argv)
  21. formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
  22. formulario.show() # Mostramos el Formulario
  23. aplicacion.exec_() # Ejecutamos
  24.  
Genial ! , ya tenemos nuestro primer programa en PyQT4. Nos aparecerá el formulario con el botón y al dar clic aparecerá el mensaje: "Gracias !"


Los puntos :
  • Dar función a un botón
  • Crear un QLabel()
  • Nuestro primer Hola mundo en PyQT4
Ya fueron tratados en esta 3era parte... En la siguiente parte explicaré como obtener los datos ingresados en un QLineEdit(), mostrarlos en un QLabel() al dar clic en un QPushButton(). Ya con eso podrán empezar a crear vuestras aplicaciones !

Fuente : http://rootcodes.com/tutorialaprende-pyqt4-con-rootcodes-parte3

Saludos , Javier !
36  Programación / Scripting / [Tutorial]Aprendiendo PyQT4 [Parte2]- JaAViEr (0x5d) en: 11 Febrero 2012, 20:13 pm
Hola nuevamente !

Siguiendo con el tutorial, pasaré a explicar como implementar un QLineEdit() y un QPushButton(), para que tengan una idea de que les hablo :
Código:
<input value="Esto es un QLineEdit()">
<input value="Esto es un QPushButton()" type="submit">
(ESO EN HTML)

  Ello mismo, pero en PyQT4. Bien, para poder insertar nuestro QLineEdit, debemos añadir bajo la línea del self.resize(200,200):
Código
  1. self.mi_qlinedit = QtGui.QLineEdit(self)
  2.  
Quedando así en nuestro form:
Código
  1. # -*- coding: utf-8 -*-
  2. from PyQt4 import QtCore, QtGui
  3. import sys
  4.  
  5. class Mi_Programa(QtGui.QWidget):
  6.  
  7.   def __init__(self, parent=None):
  8.  
  9.     QtGui.QWidget.__init__(self, parent)
  10.     self.resize(200,200) #Dimensiones del formulario
  11.     self.mi_qlinedit = QtGui.QLineEdit(self) # añadimos el QLineEdit
  12.  
  13. aplicacion = QtGui.QApplication(sys.argv)
  14. formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
  15. formulario.show() # Mostramos el Formulario
  16. aplicacion.exec_() # Ejecutamos
  17.  

Y Pues para añadir un botón:
Código
  1. self.mi_boton = QtGui.QPushButton("Hola, soy un boton!", self)
  2.  
Nuestro formulario quedaría así:
Código
  1. # -*- coding: utf-8 -*-
  2. from PyQt4 import QtCore, QtGui
  3. import sys
  4.  
  5. class Mi_Programa(QtGui.QWidget):
  6.  
  7.   def __init__(self, parent=None):
  8.  
  9.     QtGui.QWidget.__init__(self, parent)
  10.     self.resize(200,200) #Dimensiones del formulario
  11.     self.mi_boton = QtGui.QPushButton("Hola, soy un boton!", self)
  12.  
  13. aplicacion = QtGui.QApplication(sys.argv)
  14. formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
  15. formulario.show() # Mostramos el Formulario
  16. aplicacion.exec_() # Ejecutamos


Nota: Podemos utilizar cualquier variable, siempre anteponiendo el self., solo que yo usé mi_boton para darle un nombre descriptivo.

  Bien, ya sabemos como insertar nuestros primeros Widgets en PyQT4, pero verás que al mezclar ambos, solo muestra un widget, esto sucede porque no le hemos dado una ubicación, por lo que ambos se posición en las coordenadas X = 0; Y = 0 , así uno se sobre pone del otro.

Entonces, ¿ Cómo ubico mi widget donde yo quiera ?

  Sencillo ! , debemos utilizar la propiedad setGeometry(X,Y,Width, Height) , Donde X será la ubicación hacia los costados e Y arriba y abajo. Aquí es donde yo recomiendo usar el QT Designer, pues nos ayudará a ubicar nuestro Widget de manera correcta y no dirá en que ubicación se encuentra.

  Recomiendo utilizar en el botón, el height 27, que es la altura de un botón normal. El width dependerá del ancho del texto de nuestro botón. (width = ancho ; height = altura)

  En lo que respecta el QLineEdit, recomiendo usar también el height = 27
  Así quedando la mezcla:
Código
  1. # -*- coding: utf-8 -*-
  2. from PyQt4 import QtCore, QtGui
  3. import sys
  4.  
  5. class Mi_Programa(QtGui.QWidget):
  6.  
  7.   def __init__(self, parent=None):
  8.  
  9.     QtGui.QWidget.__init__(self, parent)
  10.     self.resize(200,200) #Dimensiones del formulario
  11.     self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
  12.     self.mi_boton.setGeometry(10,40,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
  13.     self.mi_qlinedit = QtGui.QLineEdit(self) # Creo el QLineEdit()
  14.     self.mi_qlinedit.setGeometry(10,10,92,27) # X = 10 ; Y = 10 ; Width = 92 ; Height = 27
  15.  
  16. aplicacion = QtGui.QApplication(sys.argv)
  17. formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
  18. formulario.show() # Mostramos el Formulario
  19. aplicacion.exec_() # Ejecutamos
Un ScreenShot:


En la siguiente parte, explicaré como darle función a un botón e implementar un QLabel() con un resultado posterior !

Fuente : http://rootcodes.com/tutorialaprende-pyqt4-con-rootcodes-parte2

Saludos, Javier !
37  Programación / Scripting / [Tutorial]Aprendiendo PyQT4 [Parte1]- JaAViEr (0x5d) en: 11 Febrero 2012, 20:00 pm
Hola, buen día.
 
    En esta ocasión vengo a "enseñar" un poco sobre lo que es la aplicación de QT4 en nuestro siempre querido Python.
   
    En esta guía pretendo explicar la base para crear un formulario y los distintos widgets a utilizar, como dar función a un botón, obtener datos de campos QLineEdit(), insertar datos en diferentes tipos de widgets, tales como QLineEdit, QPlainText, QTextBrowser, etc. Y pues ya lo demás es saber
lo básico de Python, pero en ves de pedir los datos vía raw_input() estos son reemplazados por los ya mencionados QLineEdit, para imprimir un dato por pantalla podemos usar QLabel. Ya lo demás es saber programar en Python nada más ! :D


  Bien, antes que todo, veamos que es QT, según la conocida Wikipedia :

 

Citar
Qt es una biblioteca multiplataforma ampliamente usada para desarrollar aplicaciones con una interfaz gráfica
 de usuario así como también para el desarrollo de programas sin interfaz gráfica como herramientas para
la línea de comandos y consolas para servidores.



  Ya, vamos al grano...
  ¿ Qué necesito para programar en PyQT4 ?

    Necesitas obviamente tener instalado Python:
Código:
sudo apt-get install python

    Una vez instalado, debemos instalar las librerías QT4:
Código:
sudo apt-get install python-qt4

    Esto es <em>opcional</em>, es el QT4 Designer, que nos ayuda a crear la interfaz gráfica, pero en C++
Código:
sudo apt-get install qt4-designer

    Y lo siguiente, es para traducir el código C++ a PyQT4, en caso de usar el QT4 Designer:
Código:
sudo apt-get install pyqt4-dev-tools

    Aclaro que yo a lo largo del tutorial solo usaré el QT4 Designer para saber las dimensiones de los
widgets, tamaños y propiedades.

   Bueno, volvamos al tema... Vamos a empezar !

  La base de todos los programas en PyQT4 debe ser:
Código
  1. # -*- coding: utf-8 -*-
  2. #Autor: JaAViEr(0x5d)
  3. #Website: http://www.rootcodes.com
  4. #Twitter: @0x5d
  5.  
  6. from PyQt4 import QtCore, QtGui
  7. import sys
  8.  
  9. class Mi_Programa(QtGui.QWidget):
  10.  
  11.   def __init__(self, parent=None):
  12.  
  13.     QtGui.QWidget.__init__(self, parent)
  14.     self.resize(200,200) #Dimensiones del formulario
  15.  
  16. aplicacion = QtGui.QApplication(sys.argv)
  17. formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
  18. formulario.show() # Mostramos el Formulario
  19. aplicacion.exec_() # Ejecutamos
Si has copiado y pegado bien, la salida debe ser:


 Genial, nuestra primera mini aplicación en PyQT4, en la segunda parte empezaremos a utilizar los widgets QLineEdit(), QLabel() y QPushButton()

Fuente : http://rootcodes.com/tutorialaprende-pyqt4-con-rootcodes-parte1
38  Programación / Scripting / [Código-PyQT4]All in one - JaAViEr(0x5d) en: 11 Febrero 2012, 05:11 am
Hola, tengan muy buenos días !

  Hoy, pasando por un foro en el cual participo, tocaron un tema sobre PythonQT y me recordé que hace rato que no hacía nada en él y pues tras la perdida de mi otro HDD ni instalado lo tenía en este Debian.
  
  Así que me senté a pensar que codear y se me vino a la mente meter todas las aplicaciones QT4 que he hecho (que son bien pocas) en un solo PyQT4 para acceder a ellas por un boton nada más, así que me puse en marcha y este fue el resultado :
Código
  1. # -*- coding: utf-8 -*-
  2. #Autor : 0x5d
  3. #Website : http://www.rootcodes.com
  4. #Twitter : 0x5d
  5.  
  6. import sys, urllib2, re, urllib
  7. from PyQt4 import QtCore, QtGui, QtWebKit
  8.  
  9. class all_in_one(QtGui.QWidget):
  10.  
  11.   def __init__(self, parent=None):
  12.  
  13.     QtGui.QWidget.__init__(self,parent)
  14.     self.resize(400, 203)
  15.     self.setWindowTitle('Todo en uno PyQT4 - JaAViEr')
  16.     self.boton_extractor = QtGui.QPushButton('Extractor de imagenes', self)
  17.     self.boton_extractor.setGeometry(10, 10, 171, 51)
  18.     self.connect(self.boton_extractor, QtCore.SIGNAL('clicked()'), self.show_extractor)
  19.     self.boton_digitoveri = QtGui.QPushButton('Obtener digito verificador', self)
  20.     self.boton_digitoveri.setGeometry(190, 10, 191, 51)
  21.     self.connect(self.boton_digitoveri, QtCore.SIGNAL('clicked()'), self.show_digitoveri)
  22.     self.boton_calculadorasecuencias = QtGui.QPushButton('Calculadora por secuencias', self)
  23.     self.boton_calculadorasecuencias.setGeometry(10, 70, 201, 51)
  24.     self.connect(self.boton_calculadorasecuencias, QtCore.SIGNAL('clicked()'), self.show_secuencias)
  25.     self.boton_htmlhelper = QtGui.QPushButton('HTML Helper', self)
  26.     self.boton_htmlhelper.setGeometry(10, 130, 101, 51)
  27.     self.connect(self.boton_htmlhelper, QtCore.SIGNAL('clicked()'), self.show_htmlhelper)
  28.     self.boton_twitter = QtGui.QPushButton('Menciones Twitter', self)
  29.     self.boton_twitter.setGeometry(220, 70, 161, 51)
  30.     self.connect(self.boton_twitter, QtCore.SIGNAL('clicked()'), self.show_twitter)
  31.     self.boton_calculadora = QtGui.QPushButton('Calculadora', self)
  32.     self.boton_calculadora.setGeometry(120, 130, 92, 51)
  33.     self.connect(self.boton_calculadora, QtCore.SIGNAL('clicked()'), self.show_calculadora)
  34.     self.boton_versource = QtGui.QPushButton('Ver codigo de fuente', self)
  35.     self.boton_versource.setGeometry(220, 130, 171, 51)
  36.     self.connect(self.boton_versource, QtCore.SIGNAL('clicked()'), self.show_viewsource)
  37.  
  38.   def show_extractor(self):
  39.  
  40.     extractor.show()
  41.  
  42.   def show_digitoveri(self):
  43.  
  44.     digito.show()
  45.  
  46.   def show_viewsource(self):
  47.  
  48.     source.show()
  49.  
  50.   def show_calculadora(self):
  51.  
  52.     calculadora.show()
  53.  
  54.   def show_twitter(self):
  55.  
  56.     twitter.show()
  57.  
  58.   def show_htmlhelper(self):
  59.  
  60.     html_helper.show()
  61.  
  62.   def show_secuencias(self):
  63.  
  64.     secuencia.show()
  65.  
  66. # Inicio Obtener dígito verificador
  67. class ventana_alerta(QtGui.QWidget):
  68.  
  69.   def __init__(self, parent=None):
  70.  
  71.     QtGui.QWidget.__init__(self, parent)
  72.     self.resize(283, 31)
  73.     self.setWindowTitle('ALERTA!')
  74.  
  75.   def message(self, txt):
  76.  
  77.     self.txt = txt
  78.     self.respuesta = QtGui.QLabel(self.txt, self)
  79.     self.respuesta.setGeometry(10, 10, 260, 17)
  80.  
  81. class formulario_rut(QtGui.QWidget):
  82.  
  83.   def __init__(self, parent=None):
  84.  
  85.     QtGui.QWidget.__init__(self, parent)
  86.     self.setWindowTitle('Digito verificador')
  87.     self.resize(279, 36)
  88.     self.label_rut = QtGui.QLabel('RUT', self)
  89.     self.label_rut.setGeometry(0, 11, 59, 17)
  90.     self.rut = QtGui.QLineEdit(self)
  91.     self.rut.setGeometry(30, 7, 101, 23)
  92.     self.label_verificador = QtGui.QLabel('-', self)
  93.     self.label_verificador.setGeometry(135, 11, 16, 17)
  94.     self.digito = QtGui.QLineEdit(self)
  95.     self.digito.setGeometry(147, 7, 21, 23)
  96.     self.digito.setReadOnly(True)
  97.     self.verificar = QtGui.QPushButton('Verificar', self)
  98.     self.verificar.setGeometry(180, 7, 92, 23)
  99.     self.connect(self.verificar, QtCore.SIGNAL('clicked()'), self.operacion)
  100.  
  101.   def operacion(self):
  102.  
  103.     self.rut_valor = str(self.rut.text())
  104.     if len(self.rut_valor) < 8 and len(self.rut_valor) > 9:
  105.  
  106.       creacion_alerta.message('Ingresa un rut valido por favor')
  107.       creacion_alerta.show()
  108.  
  109.     else:
  110.  
  111.       rut = []
  112.       ingresar = [rut.append(numeros) for numeros in self.rut_valor]
  113.       rut.reverse()
  114.       recorrido = 2
  115.       multiplicar = 0
  116.  
  117.       for x in rut:
  118.         multiplicar+=int(x)*recorrido
  119.         if recorrido==7: recorrido = 1
  120.         recorrido+=1
  121.  
  122.       modulo = multiplicar%11
  123.       resultado = 11-modulo
  124.       if resultado == 11: digito=0
  125.       elif resultado == 10: digito="K"
  126.       else: digito=resultado
  127.       self.digito.setText(str(digito))
  128. #Fin obtener dígito verificador 
  129.  
  130. #Inicio extractor
  131. class extractor(QtGui.QWidget):
  132.  
  133.     def __init__(self, parent=None):
  134.  
  135.       QtGui.QWidget.__init__(self, parent)
  136.       self.resize(602, 514)
  137.       self.setWindowTitle(QtGui.QApplication.translate('self', 'Extractor de imágenes :: JaAViEr (0x5d)', None, QtGui.QApplication.UnicodeUTF8))
  138.       self.label_url = QtGui.QLabel('Url', self)
  139.       self.label_url.setGeometry(10, 15, 21, 16)
  140.       self.input_url = QtGui.QLineEdit(self)
  141.       self.input_url.setGeometry(30, 13, 561, 19)
  142.       self.label_salida = QtGui.QLabel('Salida', self)
  143.       self.label_salida.setGeometry(12, 40, 57, 15)
  144.       self.boton_extraer = QtGui.QPushButton(QtGui.QApplication.translate('self', 'Extraer imágenes', None, QtGui.QApplication.UnicodeUTF8), self)
  145.       self.boton_extraer.setGeometry(469, 37, 121, 20)
  146.       self.connect(self.boton_extraer, QtCore.SIGNAL('clicked()'), self.extraer_todo)
  147.       self.listWidget = QtGui.QListWidget(self)
  148.       self.listWidget.setGeometry(QtCore.QRect(5, 60, 591, 441))
  149.  
  150.     def extraer_todo(self):
  151.  
  152.       url_imagenes = ""
  153.       clear = ""
  154.       i = 0
  155.       self.web = str(self.input_url.text())
  156.       for imagen in re.findall('<img (.*)>',urllib.urlopen(self.web).read()):
  157.         if "src" in imagen.lower():
  158.  
  159.           for imagenes in imagen.split():
  160.             if re.findall('src=(.*)',imagenes):
  161.  
  162.               clear = imagenes[:-1].replace('src=\"','"')
  163.               QtGui.QListWidgetItem(self.listWidget)
  164.               self.listWidget.item(i).setText('%s.- %s'%(i, clear.replace(self.web,'"')))
  165.               i+=1
  166. class secuencia(QtGui.QWidget):
  167.  
  168.   def __init__(self, parent=None):
  169.  
  170.     QtGui.QWidget.__init__(self, parent)
  171.     self.resize(411, 60)
  172.     self.setWindowTitle('Calculadora de secuencias :: JaAViEr(0x5d)')
  173.     self.input_secuencia = QtGui.QLineEdit(self)
  174.     self.input_secuencia.setGeometry(80, 5, 321, 21)
  175.     self.label_secuencia = QtGui.QLabel('Secuencia', self)
  176.     self.label_secuencia.setGeometry(5, 2, 71, 31)
  177.     self.boton_ver = QtGui.QPushButton('Ver', self)
  178.     self.boton_ver.setGeometry(323, 30, 81, 21)
  179.     self.input_resultado = QtGui.QLineEdit(self)
  180.     self.input_resultado.setGeometry(80, 30, 240, 21)
  181.     self.input_resultado.setReadOnly(True)
  182.     self.label_resultado = QtGui.QLabel('Resultado', self)
  183.     self.label_resultado.setGeometry(5, 31, 71, 21)
  184.     self.connect(self.boton_ver, QtCore.SIGNAL('clicked()'), self.ejecutar)
  185.  
  186.   def ejecutar(self):
  187.  
  188.     try:
  189.  
  190.       self.resultado = str(self.input_secuencia.text())
  191.       self.input_resultado.setText(str(eval(self.resultado)))
  192.  
  193.     except:
  194.  
  195.       self.input_resultado.setText(QtGui.QApplication.translate('self', 'Operación inválida', None, QtGui.QApplication.UnicodeUTF8))
  196.  
  197. class html_helper(QtGui.QMainWindow):
  198.  
  199.   def __init__(self):
  200.  
  201.     QtGui.QMainWindow.__init__(self)
  202. #Boton Bold
  203.     self.bold = QtGui.QPushButton('Bold',self)
  204.     self.bold.setGeometry(172,26,41,25)
  205.     self.connect(self.bold,QtCore.SIGNAL('clicked()'), self.make_bold)
  206. #Boton Italic
  207.     self.italic = QtGui.QPushButton('Italic',self)
  208.     self.italic.setGeometry(216,26,41,25)
  209.     self.connect(self.italic,QtCore.SIGNAL('clicked()'), self.make_italic)
  210. #Boton Underline
  211.     self.underline = QtGui.QPushButton('Underline',self)
  212.     self.underline.setGeometry(261,26,63,25)
  213.     self.connect(self.underline,QtCore.SIGNAL('clicked()'), self.make_underline)
  214. #Nuevo menu "Archivo"
  215.     menu_archivo = self.menuBar()
  216.     archivo = menu_archivo.addMenu('&Archivo')
  217. #Menu Abrir
  218.     abrir = QtGui.QAction('&Abrir',self)
  219.     abrir.setShortcut('Ctrl+O')
  220.     archivo.addAction(abrir)
  221.     self.connect(abrir, QtCore.SIGNAL('triggered()'),self.abrir)
  222. #Menu Abrir URL
  223.     abrir_url = QtGui.QAction('Abrir desde &URL',self)
  224.     abrir_url.setShortcut('Ctrl+U')
  225.     archivo.addAction(abrir_url)
  226.     self.connect(abrir_url, QtCore.SIGNAL('triggered()'),self.get_source)
  227. #Menu Guardar
  228.     guardar = QtGui.QAction('&Guardar',self)
  229.     guardar.setShortcut('Ctrl+S')
  230.     archivo.addAction(guardar)
  231.     self.connect(guardar, QtCore.SIGNAL('triggered()'),self.guardar)
  232. #Menu salir
  233.     salida = QtGui.QAction('&Exit', self)
  234.     salida.setShortcut('Ctrl+W')
  235.     archivo.addAction(salida)
  236.     self.connect(salida, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))
  237. #Fin del menú Archivo
  238. #Nuevo menú Herramientas
  239.     menu_inputs = self.menuBar()
  240.     herramientas = menu_inputs.addMenu('&Herramientas')
  241. #Menu textarea
  242.     textarea = QtGui.QAction('Agregar &TextArea', self)
  243.     herramientas.addAction(textarea)
  244.     self.connect(textarea, QtCore.SIGNAL('triggered()'), self.add_textarea)
  245. #Menu input
  246.     inputx = QtGui.QAction('Agregar &Input', self)
  247.     herramientas.addAction(inputx)
  248.     self.connect(inputx, QtCore.SIGNAL('triggered()'), self.add_input)
  249. #Menu Boton
  250.     boton = QtGui.QAction('Agregar &Boton', self)
  251.     herramientas.addAction(boton)
  252.     self.connect(boton, QtCore.SIGNAL('triggered()'), self.add_button)
  253. #Menu Imagen
  254.     imagen = QtGui.QAction('Agregar I&magen', self)
  255.     herramientas.addAction(imagen)
  256.     self.connect(imagen, QtCore.SIGNAL('triggered()'), self.add_imagen)
  257. #Menu Cambiar Fondo
  258.     fondo = QtGui.QAction('Color de &Fondo', self)
  259.     herramientas.addAction(fondo)
  260.     self.connect(fondo, QtCore.SIGNAL('triggered()'), self.add_fondo)
  261. #Menu Link
  262.     link = QtGui.QAction('Agregar &Link', self)
  263.     herramientas.addAction(link)
  264.     self.connect(link, QtCore.SIGNAL('triggered()'), self.add_link)
  265. #Fin menú Herramientas
  266.     self.resize(729, 674)
  267.     self.pest_code = QtGui.QTabWidget(self)
  268.     self.pest_code.setGeometry(QtCore.QRect(0, 30, 711, 631))
  269.     self.tab = QtGui.QWidget()
  270.     self.html_plano = QtGui.QPlainTextEdit(self.tab)
  271.     self.html_plano.setGeometry(QtCore.QRect(10, 30, 691, 571))
  272.     self.boton_previw = QtGui.QPushButton('Preview',self.tab)
  273.     self.boton_previw.setGeometry(QtCore.QRect(10, 4,83, 21))
  274.     self.pest_code.addTab(self.tab, '')
  275.     self.tab_2 = QtGui.QWidget()
  276. #Nuevo menú Fuente / Colores
  277.     font_color = self.menuBar()
  278.     fuentes_colores = font_color.addMenu('&Fuente / Colores')
  279. #Menu Buscar Color
  280.     search_color = QtGui.QAction('Buscar Color', self)
  281.     fuentes_colores.addAction(search_color)
  282.     self.connect(search_color, QtCore.SIGNAL('triggered()'), self.find_color)
  283. #Menu buscar Fuente
  284.     search_font = QtGui.QAction('Buscar Fuente', self)
  285.     fuentes_colores.addAction(search_font)
  286.     self.connect(search_font, QtCore.SIGNAL('triggered()'), self.find_font)
  287.     self.vista_web = QtWebKit.QWebView(self.tab_2)
  288.     self.vista_web.setGeometry(QtCore.QRect(10, 10, 691, 591))
  289.     self.pest_code.addTab(self.tab_2, '')
  290.     self.pest_code.setCurrentIndex(0)
  291.     QtCore.QMetaObject.connectSlotsByName(self)
  292.     self.setWindowTitle('Create HTML Helper.')
  293.     self.pest_code.setTabText(self.pest_code.indexOf(self.tab),'Codigo')
  294.     self.pest_code.setTabText(self.pest_code.indexOf(self.tab_2), 'Prevista')
  295.     self.connect(self.boton_previw, QtCore.SIGNAL('clicked()'), self.done)  
  296.  
  297.   def make_bold(self):
  298.  
  299.     self.html_final = "%s<br />\n<b></b>"%self.html_plano.toPlainText()
  300.     self.html_plano.setPlainText(self.html_final)  
  301.  
  302.   def make_italic(self):
  303.  
  304.     self.html_final = "%s<br />\n<i></i>"%self.html_plano.toPlainText()
  305.     self.html_plano.setPlainText(self.html_final)  
  306.  
  307.   def make_underline(self):
  308.  
  309.     self.html_final = "%s<br />\n<u></u>"%self.html_plano.toPlainText()
  310.     self.html_plano.setPlainText(self.html_final)  
  311.  
  312.   def done(self):
  313.  
  314.     self.salida = self.html_plano.toPlainText()
  315.     temporal = open('tmp.html','w')
  316.     temporal.write(self.salida)
  317.     temporal.close()
  318.     self.vista_web.setUrl(QtCore.QUrl('tmp.html'))
  319.     self.pest_code.setCurrentIndex(1)
  320.  
  321.   def guardar(self):
  322.  
  323.     self.obtener_html = self.html_plano.toPlainText()
  324.     try:
  325.  
  326.       nombre_save = QtGui.QFileDialog.getSaveFileName(self, 'Guardar Archivo','/home')
  327.       guardando_html = open(nombre_save, 'w')
  328.       guardando_html.write(self.obtener_html)
  329.       guardando_html.close()
  330.       alertas.show()
  331.       alertas.alerta('Advertencia','Guardado!')
  332.     except:
  333.  
  334.       alertas.show()
  335.       alertas.alerta('Advertencia','No Guardado')
  336.  
  337.   def abrir(self):
  338.  
  339.     nombre_open = QtGui.QFileDialog.getOpenFileName(self, 'Abrir Archivo','/home')
  340.     abriendo_html = open(nombre_open, 'r')
  341.     contenido = abriendo_html.read()
  342.     self.html_plano.setPlainText(contenido)
  343.  
  344.   def add_textarea(self):
  345.  
  346.     rows, respuesta_rows = QtGui.QInputDialog.getText(self, 'Rows','Numero de Lineas:')
  347.     if respuesta_rows:
  348.  
  349.       rows = " rows=\"%s\""%str(rows)
  350.     else:
  351.  
  352.       rows = ""
  353.     cols, respuesta_cols = QtGui.QInputDialog.getText(self, 'Cols','Numero de Columnas:')
  354.     if respuesta_cols:
  355.  
  356.       cols = " cols=\"%s\""%str(cols)
  357.     else:
  358.  
  359.       cols = ""
  360.     self.html_final = "%s<br />\n<textarea%s%s></textarea>"%(self.html_plano.toPlainText(),rows,cols)
  361.     self.html_plano.setPlainText(self.html_final)  
  362.  
  363.   def add_input(self):
  364.  
  365.     value, respuesta_value = QtGui.QInputDialog.getText(self, 'Valor','Valor por defecto:')
  366.     if respuesta_value:
  367.  
  368.       value = " value=\"%s\""%str(value)
  369.     else:
  370.  
  371.       value = ""
  372.     self.html_final = "%s<br />\n<input%s>"%(self.html_plano.toPlainText(),value)
  373.     self.html_plano.setPlainText(self.html_final)  
  374.  
  375.   def add_button(self):
  376.  
  377.     button, respuesta_boton = QtGui.QInputDialog.getText(self, 'Valor','Valor del Boton:')
  378.     if respuesta_boton:
  379.  
  380.       button = " value=\"%s\""%str(button)
  381.     else:
  382.  
  383.       button = ""
  384.     self.html_final = "%s<br />\n<input  type=\"Submit\"%s>"%(self.html_plano.toPlainText(),button)
  385.     self.html_plano.setPlainText(self.html_final)  
  386.  
  387.   def add_imagen(self):
  388.  
  389.     imagen, respuesta_imagen = QtGui.QInputDialog.getText(self, 'Valor','URL de la Imagen:')
  390.     if respuesta_imagen:
  391.  
  392.       imagen = " src=\"%s\""%str(imagen)
  393.     else:
  394.  
  395.       imagen = ""
  396.     width, respuesta_width = QtGui.QInputDialog.getText(self, 'Valor','Ancho:')
  397.     if respuesta_width:
  398.  
  399.       width = " width=\"%s\""%str(width)
  400.     else:
  401.  
  402.       width = ""
  403.     height, respuesta_height = QtGui.QInputDialog.getText(self, 'Valor','Alto:')
  404.     if respuesta_height:
  405.  
  406.       height = " height=\"%s\""%str(height)
  407.     else:
  408.  
  409.       height = ""
  410.     self.html_final = "%s<br />\n<img%s%s%s>"%(self.html_plano.toPlainText(),imagen,width,height)
  411.     self.html_plano.setPlainText(self.html_final)  
  412.  
  413.   def add_fondo(self):
  414.  
  415.     color = QtGui.QColorDialog.getColor()
  416.     if color.isValid():
  417.  
  418.       if not "<body" in self.html_plano.toPlainText():
  419.         self.html_final = "<body bgcolor=\"%s\">%s</body>"%(color.name(),self.html_plano.toPlainText())
  420.         self.html_plano.setPlainText(self.html_final)
  421.       else:
  422.  
  423.         for i in re.findall('<body bgcolor=\"(.*)\">',self.html_plano.toPlainText()):
  424.           anterior=i
  425.         self.html_final = self.html_plano.toPlainText().replace(anterior,color.name())
  426.  
  427.         self.html_plano.setPlainText(self.html_final)
  428.     else:
  429.  
  430.       self.html_final = "<body bgcolor=\"#FFFFFF\">%s</body>"%(self.html_plano.toPlainText())
  431.       self.html_plano.setPlainText(self.html_final)
  432.  
  433.   def find_color(self):
  434.  
  435.     busca_color= QtGui.QColorDialog.getColor()
  436.     if busca_color.isValid():
  437.       alertas.show()
  438.       alertas.alerta('Advertencia','Color %s'%busca_color.name())
  439.  
  440.   def get_source(self):
  441.  
  442.     url, respuesta_url = QtGui.QInputDialog.getText(self, 'Get','URL:')
  443.     try:
  444.  
  445.       self.html_plano.setPlainText(urllib2.urlopen(str(url)).read())
  446.  
  447.     except:
  448.  
  449.       alertas.show()
  450.       alertas.alerta('Advertencia','Contenido no encontrado')
  451.  
  452.   def add_link(self):
  453.  
  454.     link, respuesta_link = QtGui.QInputDialog.getText(self, 'Link','Link:')
  455.     if respuesta_link:
  456.  
  457.       link = " href=\"%s\""%link
  458.  
  459.     else:
  460.  
  461.       link = ""
  462.  
  463.     name, respuesta_name = QtGui.QInputDialog.getText(self, 'Nombre','Nombre:')
  464.     if respuesta_name:
  465.  
  466.       name = "%s"%name
  467.  
  468.     else:
  469.  
  470.       name = "%s"%link
  471.     self.html_final = "%s<br />\n<a%s>%s</a>"%(self.html_plano.toPlainText(),link,name)
  472.     self.html_plano.setPlainText(self.html_final)  
  473.  
  474.   def find_font(self):
  475.  
  476.     QtGui.QFontDialog.getFont()
  477.  
  478. class myalert(QtGui.QMainWindow):
  479.  
  480.   def __init__(self):
  481.  
  482.     QtGui.QMainWindow.__init__(self)
  483.     #self.resize(130,50)
  484.     self.setGeometry(400,300,250,50)
  485.     self.label_problema = QtGui.QLabel(self)
  486.     self.label_problema.setGeometry(40,17,180,20)
  487.  
  488.   def alerta(self,error,razon):
  489.  
  490.     self.setWindowTitle(error)
  491.     self.label_problema.setText(razon)
  492.  
  493.  
  494. class twitter(QtGui.QWidget):
  495.  
  496.   def __init__(self, parent=None):
  497.  
  498.     QtGui.QWidget.__init__(self,parent)
  499.     cookie = urllib2.HTTPCookieProcessor()
  500.     opener = urllib2.build_opener(cookie)
  501.     urllib2.install_opener(opener)
  502.     self.resize(546, 525)
  503.     self.usuario = QtGui.QLineEdit(self)
  504.     self.usuario.setGeometry(70, 10, 201, 21)
  505.     self.l_usuario = QtGui.QLabel('Usuario :',self)
  506.     self.l_usuario.setGeometry(10, 14, 57, 15)
  507.     self.clave = QtGui.QLineEdit(self)
  508.     self.clave.setGeometry(70, 40, 201, 21)
  509.     self.clave.setEchoMode(QtGui.QLineEdit.Password)
  510.     self.l_clave = QtGui.QLabel('Clave :',self)
  511.     self.l_clave.setGeometry(10, 44, 57, 15)
  512.     self.mencion = QtGui.QTextBrowser(self)
  513.     self.mencion.setGeometry(10, 100, 531, 411)
  514.     self.l_menciones = QtGui.QLabel('Tus Menciones : ',self)
  515.     self.l_menciones.setGeometry(10, 70, 111, 16)
  516.     self.login = QtGui.QPushButton('Ingresar !',self)
  517.     self.login.setGeometry(300, 25, 171, 25)
  518.     self.setWindowTitle('Menciones Twitter - [JaAViEr]')
  519.     self.connect(self.login,QtCore.SIGNAL('clicked()'),self.ingreso)
  520.     self.refresh = QtGui.QPushButton('Refrescar',self)
  521.     self.refresh.setGeometry(0,0,0,0)
  522.  
  523.   def ingreso(self):
  524.  
  525.     user=str(self.usuario.text());passwd=str(self.clave.text())
  526.     for token in re.findall('name=\"authenticity_token\" type=\"hidden\" value=\"(.*)\"',urllib2.urlopen('https://mobile.twitter.com/session').read()):
  527.       dato = {'authenticity_token':token,'username':user,'password':passwd}
  528.       urllib2.urlopen('https://mobile.twitter.com/session',urllib.urlencode(dato)).read()
  529.       if "Sign out" in urllib2.urlopen('https://mobile.twitter.com/').read():
  530.  
  531.         self.refresh.setGeometry(300, 60, 171, 25)
  532.         self.connect(self.refresh,QtCore.SIGNAL('clicked()'),self.mentions)
  533.         self.mentions()
  534.  
  535.   def mentions(self):
  536.  
  537.     mensaje=""
  538.     for persona,msj in zip(re.findall('<strong><a href=\"(.*)\">(.*)</a></strong>',urllib2.urlopen('https://mobile.twitter.com/replies').read()),re.findall('<span class=\"status\">(.*)</span>',urllib2.urlopen('https://mobile.twitter.com/replies').read())):
  539.       if not persona in ["Find people','Help','Sign out"]:
  540.  
  541.         mensaje+="<b>%s</b> %s<hr>"%(persona[1],msj)
  542.     self.mencion.setHtml('<body bgcolor=#c0deed><div style=color:black>%s</div>'%mensaje)
  543.  
  544.  
  545. class calculadora(QtGui.QWidget):
  546.  
  547.     def __init__(self, parent=None):
  548.  
  549.         QtGui.QWidget.__init__(self, parent)
  550.         self.setWindowTitle('Calculadora')
  551.         self.resize(119, 145)
  552.         self.temp=""
  553.         self.igual = QtGui.QPushButton('=',self)
  554.         self.igual.setGeometry(90, 120, 31, 24)
  555.         self.multiplica = QtGui.QPushButton('*',self)
  556.         self.multiplica.setGeometry(0, 120, 31, 24)
  557.         self.connect(self.multiplica,QtCore.SIGNAL('clicked()'),self.multiplicar)
  558.         self.clean = QtGui.QPushButton('AC',self)
  559.         self.clean.setGeometry(30, 120, 31, 24)
  560.         self.connect(self.clean,QtCore.SIGNAL('clicked()'),self.clear)
  561.         self.divide = QtGui.QPushButton('/',self)
  562.         self.connect(self.divide,QtCore.SIGNAL('clicked()'),self.dividir)
  563.         self.divide.setGeometry(0, 90, 31, 24)
  564.         self.connect(self.igual,QtCore.SIGNAL('clicked()'),self.resultado)
  565.         self.resta = QtGui.QPushButton('-',self)
  566.         self.resta.setGeometry(0, 60, 31, 24)
  567.         self.connect(self.resta,QtCore.SIGNAL('clicked()'),self.restar)
  568.         self.suma = QtGui.QPushButton('+',self)
  569.         self.suma.setGeometry(0, 30, 31, 24)
  570.         self.connect(self.suma,QtCore.SIGNAL('clicked()'),self.sumar)
  571.         self.lineEdit = QtGui.QLineEdit(self)
  572.         self.lineEdit.setGeometry(QtCore.QRect(0, 0, 121, 25))
  573.         self.uno = QtGui.QPushButton('1',self)
  574.         self.connect(self.uno,QtCore.SIGNAL('clicked()'),self.inu)
  575.         self.uno.setGeometry(QtCore.QRect(30, 30, 31, 24))
  576.         self.dos = QtGui.QPushButton('2',self)
  577.         self.connect(self.dos,QtCore.SIGNAL('clicked()'),self.ind)
  578.         self.dos.setGeometry(QtCore.QRect(60, 30, 31, 24))
  579.         self.tres = QtGui.QPushButton('3',self)
  580.         self.connect(self.tres,QtCore.SIGNAL('clicked()'),self.intr)
  581.         self.tres.setGeometry(QtCore.QRect(90, 30, 31, 24))
  582.         self.cuatro = QtGui.QPushButton('4',self)
  583.         self.connect(self.cuatro,QtCore.SIGNAL('clicked()'),self.inc)
  584.         self.cuatro.setGeometry(QtCore.QRect(30, 60, 31, 24))
  585.         self.cinco = QtGui.QPushButton('5',self)
  586.         self.connect(self.cinco,QtCore.SIGNAL('clicked()'),self.inci)
  587.         self.cinco.setGeometry(QtCore.QRect(60, 60, 31, 24))
  588.         self.seis = QtGui.QPushButton('6',self)
  589.         self.connect(self.seis,QtCore.SIGNAL('clicked()'),self.ins)
  590.         self.seis.setGeometry(QtCore.QRect(90, 60, 31, 24))
  591.         self.nueve = QtGui.QPushButton('9',self)
  592.         self.connect(self.nueve,QtCore.SIGNAL('clicked()'),self.inn)
  593.         self.nueve.setGeometry(QtCore.QRect(90, 90, 31, 24))
  594.         self.ocho = QtGui.QPushButton('8',self)
  595.         self.connect(self.ocho,QtCore.SIGNAL('clicked()'),self.ino)
  596.         self.ocho.setGeometry(QtCore.QRect(60, 90, 31, 24))
  597.         self.siete = QtGui.QPushButton('7',self)
  598.         self.connect(self.siete,QtCore.SIGNAL('clicked()'),self.insi)
  599.         self.siete.setGeometry(QtCore.QRect(30, 90, 31, 24))
  600.         self.cero = QtGui.QPushButton('0',self)
  601.         self.cero.setGeometry(QtCore.QRect(60, 120, 31, 24))
  602.         self.connect(self.cero,QtCore.SIGNAL('clicked()'),self.ince)
  603.  
  604.     def clear(self):
  605.  
  606.       self.temp=""
  607.       self.lineEdit.setText('')
  608.  
  609.     def restar(self):
  610.  
  611.       self.temp+="-"
  612.       self.lineEdit.setText(self.temp)
  613.  
  614.     def dividir(self):
  615.  
  616.       self.temp+="/"
  617.       self.lineEdit.setText(self.temp)
  618.  
  619.     def multiplicar(self):
  620.  
  621.       self.temp+="*"
  622.       self.lineEdit.setText(self.temp)
  623.  
  624.     def sumar(self):
  625.  
  626.         self.temp+="+"
  627.         self.lineEdit.setText(self.temp)
  628.  
  629.     def resultado(self):
  630.  
  631.         if len(self.temp)>0:
  632.  
  633.           final=eval(self.temp)
  634.           self.lineEdit.setText(str(final))
  635.           self.temp=str(final)
  636.  
  637.         else:
  638.  
  639.           final=eval(str(self.lineEdit.text()))
  640.           print final
  641.           self.lineEdit.setText(str(final))
  642.           self.temp=str(final)
  643.  
  644.     def inu(self):
  645.  
  646.         self.temp+="1"
  647.         self.lineEdit.setText(self.temp)
  648.  
  649.     def ind(self):
  650.  
  651.         self.temp+="2"
  652.         self.lineEdit.setText(self.temp)
  653.  
  654.     def intr(self):
  655.  
  656.         self.temp+="3"
  657.         self.lineEdit.setText(self.temp)
  658.  
  659.     def inc(self):
  660.  
  661.         self.temp+="4"
  662.         self.lineEdit.setText(self.temp)
  663.  
  664.     def inci(self):
  665.  
  666.         self.temp+="5"
  667.         self.lineEdit.setText(self.temp)
  668.  
  669.     def ins(self):
  670.  
  671.         self.temp+="6"
  672.         self.lineEdit.setText(self.temp)
  673.  
  674.     def insi(self):
  675.  
  676.         self.temp+="7"
  677.         self.lineEdit.setText(self.temp)
  678.  
  679.     def ino(self):
  680.  
  681.         self.temp+="8"
  682.         self.lineEdit.setText(self.temp)
  683.  
  684.     def inn(self):
  685.  
  686.         self.temp+="9"
  687.         self.lineEdit.setText(self.temp)
  688.  
  689.     def ince(self):
  690.  
  691.         self.temp+="0"
  692.         self.lineEdit.setText(self.temp)
  693.  
  694.  
  695. class view_source(QtGui.QWidget):
  696.  
  697.     def __init__(self, parent=None):
  698.  
  699.         QtGui.QWidget.__init__(self,parent)
  700.         self.resize(466, 407)
  701.         self.vercode = QtGui.QPushButton('View Source',self)
  702.         self.vercode.setGeometry(200, 380, 105, 24)
  703.         self.http_host = QtGui.QLineEdit(self)
  704.         self.http_host.setGeometry(90, 10, 371, 25)
  705.         self.http_host.setEchoMode(QtGui.QLineEdit.Normal)
  706.         self.url = QtGui.QLabel('Host / URL',self)
  707.         self.url.setGeometry(20, 17, 71, 16)
  708.         self.viewcode = QtGui.QLabel('View Source',self)
  709.         self.viewcode.setGeometry(10, 35, 121, 16)
  710.         self.code = QtGui.QPlainTextEdit(self)
  711.         self.code.setGeometry(0, 50, 461, 331)
  712.         self.code.setFrameShadow(QtGui.QFrame.Raised)
  713.         self.setWindowTitle('View Source - JaAViEr')
  714.         self.connect(self.vercode,QtCore.SIGNAL('clicked()'),self.vista_code)
  715.  
  716.     def vista_code(self):
  717.  
  718.       pagina=urllib2.urlopen(str(self.http_host.text()))
  719.       self.code.setPlainText(pagina.read())
  720.  
  721. correr = QtGui.QApplication(sys.argv)
  722. formulario = all_in_one()
  723. formulario.show()
  724. calculadora = calculadora()
  725. twitter = twitter()
  726. html_helper = html_helper()
  727. secuencia = secuencia()
  728. extractor = extractor()
  729. digito = formulario_rut()
  730. source = view_source()
  731. correr.exec_()
  732.  
Screenshot :


 Luego es cuestión de dar clic en los botones para utilizar las herramientas !

Fuente : http://rootcodes.com/pyqt4all-in-one-recopilatorio-de-qt4-jaavier

Saludos, Javier
39  Programación / Scripting / [Código-Python]Obtener dígito verificador del RUT en Chile - JaAViEr en: 9 Febrero 2012, 21:03 pm
Hola, buen día !

Tras unas merecidas vacaciones vengo de vuelta con cosas para programar, con la cabeza ya más despejada :P.

Visitando el blog del colega <a href="http://twitter.com/isseu">@isseu</a>, me encuentro con un artículo llamado "Como sacar dígito verificador de rol único tributario (RUT)". Me pareció interesante y me puse a leer atentamente su explicación y me animé a pasarlo a Python, en su blog está en javascript, pero yo como buen amante de Python lo hice en él :)

Código
  1. # -*- coding: utf-8 -*-
  2. rut = []
  3. ingresar = [rut.append(numeros) for numeros in raw_input('RUT ::>')]
  4. rut.reverse()
  5. recorrido = 2
  6. multiplicar = 0
  7. for x in rut:
  8. multiplicar+=int(x)*recorrido
  9. if recorrido==7: recorrido = 1
  10. recorrido+=1
  11. modulo = multiplicar%11
  12. resultado = 11-modulo
  13. if resultado == 11: digito=0
  14. elif resultado == 10: digito="K"
  15. else: digito=resultado
  16. print "Dígito verificador:",digito

Espero sea de su agrado ! :D

Fuente : http://rootcodes.com/pythonobtener-digito-verificador-del-rut-en-chile/

Saludos, Javier.
40  Programación / Scripting / [Python] Enviar peticiones POST a sitios Webs. - JaAViEr (0x5d) en: 24 Enero 2012, 19:53 pm
Hola, muy buenos días a todos !
 En esta mini guía o vengo a explicar una cosa sencilla de Python, pero que muy pocos utilizan. Me refiero a enviar datos mediante la petición POST.
Primero que nada, quiero mostrar las diferentes formas de llevar a cabo estas peticiones, una de ellas, es mediante la librería "httplib", la otra es mediante la librería urllib o urllib2.

Una ventaja aparente que veo yo al utilizar la librería httplib, es que podemos manejar los códigos de error que nos devuelven las peticiones que hagamos. Por si no manejan dichos códigos de error, acá les dejo un listado de los principales :
  • 200 : OK, documento entregado correctamente.
  • 202 : Aceptada, pero la petición no es completada con éxito.
  • 204 : Sin contenido.
  • 301 : Movido permanentemente.
  • 302 : Movido Temporalmente.
  • 304 : No modificado.
  • 401 : No autorizado.
  • 403 : Prohibido, el conocido Forbidden
  • 404 : No encontrado.
  • 500 : Error interno.
  • 501 : No implementado.
Bueno, volviendo al tema... Para enviar una petición POST, debemos saber la URL a la que deseamos enviar los datos, eso es bastante fácil, ya que generalmente solo debemos mirar el código de fuente y buscar <form ... y ubicar el action="ACÁ LA URL". Una vez encontrado ello, debemos saber que datos tenemos que enviarle a la URL, para ello deberás buscar los <input type="text" o type="hidden".

  Ahora, si no te quieres complicar la vida buscando en el código de fuente, puedes usar otra herramienta proporcionada por mi, que detecta formulario y campos a enviar mediante el POST:
Código
  1. # -*- coding: utf-8 -*-
  2. # Autor: JaAViEr (0x5d)
  3. # Twitter: 0x5d
  4. import re,urllib,sys
  5. try:
  6.   var = urllib.urlopen(raw_input("URL ::> ")).read()
  7. except:
  8.   print "No es posible conectar..."
  9.   sys.exit(1)
  10. url_enviar=""
  11. for url in re.findall("<form (.*)>",var):
  12.   if "action" in url.lower():
  13.     for web in url.split():
  14.       if re.findall("action=(.*)",web):
  15.         url_enviar=web.replace("action=","")
  16. url_enviar = url_enviar.replace("\"","")
  17. datos_r = []
  18. for campos in re.findall("<input (.*)>",var):
  19.   if "name" in campos.lower():
  20.     for cam in campos.split():
  21.       if re.findall("name=(.*)",cam):
  22.         datos_r.append(cam.replace('"',""))
  23. print "URL a enviar POST:",url_enviar.replace(">","")
  24. print "Campos Detectados:"
  25. for s in datos_r:
  26.   print s.replace("name=","")
  Solo basta con ingresar la URL para saber a que URL apunta el formulario & los datos que tenemos que enviar, podría ser buena herramienta para esta ocasión.

  Ahora que ya tenemos todos nuestros datos necesarios y fundamentales, manos a la obra !
  Veamos que tal nos va con el famoso httplib y urllib para poder codificar los datos y que el navegador los comprenda, primero los importamos:
Código
  1. import httplib, urllib
Para poder crear una conexión utilizamos:
Código
  1. parametros = urllib.urlencode({'campo1': 'valor uno','campo2':'valor2'})
En este caso, estamos enviando campo1 con el valor: valor uno y campo2 con el valor: valor2
Y Bueno, necesitamos enviar la cabecera necesaria para poder realizar con éxito nuestra petición, Content-type : application/x-www-form-urlencoded, que en Python es:
Código
  1. cabeceras = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
Bien, una vez ya tenemos todo esto en nuestro código, debemos especificar a que host nos queremos conectar y con que puerto :
Código
  1. abrir_conexion = httplib.HTTPConnection("rootcodes.com:80")
Con eso ya abrimos nuestra conexión a rootcodes.com vía puerto 80 (HTTP). Por lo tanto, ahora necesitamos especificar la URL o el archivo en el servidor que nos receptará los datos:
Código
  1. abrir_conexion.request("POST", "/archivo_cualquiera.php", parametros, cabeceras)
Genial ! , ya tenemos nuestra conexión establecida con rootcodes.com y le acabamos de enviar los datos "campo1" y "campo2" con sus respectivos valores ! , pero falta algo, saber si nuestra apreciada petición fue realizada con éxito:
Código
  1. respuesta = abrir_conexion.getresponse()
  2. print respuesta.status
  Ahí es donde entran en juego los códigos de error que les dejé más arriba.
PD: respuesta.status devolverá el código de error en número, mientras que:
Código
  1. print respuesta.reason
  Nos devolverá en texto, en caso de ser una respuesta válida, el status será 200 y el reason "OK"
  Ya una vez finalizado todo, podemos obtener el código de fuente & posteriormente cerrar la conexión:
Código
  1. ver_source = respuesta.read()
  2. abrir_conexion.close()
  Bien, código final:
Código
  1. import httplib, urllib
  2. parametros = urllib.urlencode({'campo1': 'valor uno','campo2':'valor2'})
  3. cabeceras = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
  4. abrir_conexion = httplib.HTTPConnection("rootcodes.com:80")
  5. abrir_conexion.request("POST", "/archivo_cualquiera.php", parametros, cabeceras)
  6. respuesta = abrir_conexion.getresponse()
  7. print respuesta.status
  8. ver_source = respuesta.read()
  9. #Esto es opcional -> print ver_source
  10. abrir_conexion.close()

  Bien, eso es con la "famosa" httplib, qué tal si vemos ahora como hacerlo con urllib ?

  Bueno, empiezo de 0 con urllib, lo bueno es que esto es muchísimo más sencillo, ya verán ;)
 Primero, importamos la librería :
Código
  1. import urllib
  Para establecer los campos a enviar, es igual al anterior:
Código
  1. campos = urllib.urlencode({"campo":"valor"})
  Y para establecer la web a la cuál enviar los datos:
Código
  1. sitio = urllib.urlopen("http://rootcodes.com/el_archivo.php", campos)
  2. print sitio.read()

  Basta con eso, para enviar el campo: "nombre" con valor: JaAViEr.
 Sencillo no ? , pues claro, el único problema es que tendríamos que utilizar expresiones regulares para detectar si nuestra petición fue realizada con éxito o no, por lo que es mejor utilizar httplib, cosa que yo no hago :P

  De yapa les dejaré una mini clase que hice en Python, para enviar datos por POST fácilmente:
Código
  1. # -*- coding: utf-8 -*-
  2. # Autor: JaAViEr (0x5d)
  3. # Twitter: 0x5d
  4. import re,urllib,sys
  5. try:
  6.   var = urllib.urlopen(raw_input('URL ::> ')).read()
  7. except:
  8.   print "No es posible conectar..."
  9.   sys.exit(1)
  10. url_enviar=""
  11. for url in re.findall("<form (.*)>",var):
  12.   if "action" in url.lower():
  13.     for web in url.split():
  14.       if re.findall("action=(.*)",web):
  15.         url_enviar=web.replace("action=",'')
  16. url_enviar = url_enviar.replace("\"",'')
  17. datos_r = []
  18. for campos in re.findall("<input (.*)>",var):
  19.   if "name" in campos.lower():
  20.     for cam in campos.split():
  21.       if re.findall("name=(.*)",cam):
  22.         datos_r.append(cam.replace('"',''))
  23. print "URL a enviar POST:",url_enviar.replace(">",'')
  24. print "Campos Detectados:"
  25. for s in datos_r:
  26.   print s.replace("name=",'')
Un ejemplo de uso:
Código
  1. Inserta la URL ::> http://sitio web
  2. Inserta las variables, separadas por ':' ::> campo1:campo2
  3. Inserta los valores, separados por ':' ::> valor1:valor2
  4. ACÁ IRÁ LA SALIDA

  Espero no haber sido muy enredado en mi explicación.

Fuente Original : http://rootcodes.com/pythonenviar-peticiones-post-desde-python/  O TAMBIÉN -> http://foros.cristalab.com/enviar-peticiones-post-a-sitios-web-con-python-t103492/

Saludos, Javier.
Páginas: 1 2 3 [4] 5 6
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines