31 jul. 2012

Captura de vídeo con Python y SimpleCV. Parte 4.

En este artículo se muestra como generar un vídeo usando la webcam del computador con python y SimpleCV.

El script simplemente define la captura de vídeo, genera un ciclo donde se captura el vídeo y se muestra en pantalla. Cuando se presiona la tecla espaciadora se hace una captura de una imagen y se salva, al presionar la tecla Escape se finaliza el ciclo de captura de vídeo.

El código se muestra a continuación:

#!/usr/bin/env python

#Se importa cv2.

import cv2




# se crea la instancia de la captura de Video.

video = cv2.VideoCapture(0)

#Se define un ciclo.

while True:

    #Se captura el video de la webcam

    ret,im = video.read()

    #Se muestra el video  donde se pasa im que es la lectura del video de la webcam.

    cv2.imshow('Prueba de video',im)

    #Se captura la tecla de escape del teclado

    tecla = cv2.waitKey(10)

    if tecla == 27:

        #Si es la tecla escape se termina el ciclo

        break

    #Si la tecla es el espacio en blanco se captura una imagen del video.

    if tecla == ord(' '):

        cv2.imwrite('captura_img.jpg',im)

A continuación se muestra el vídeo:


En la siguiente imagen se muestra la captura de la foto al grabar el vídeo:

30 jul. 2012

Modificar imagen con simpleCV(binarización). Parte 3.

Este artículo se explicará como convertir una imagen a dos colores, osea tomar una foto normal y convertirla en blanco y negro.

Se usará la función binarized, se puede pasar un valor entre 0 y 255 (donde cero es negro y 255 es blanco).

Se toma la imagen y luego se pasa la función a la imagen.

A continuación se muestra la imagen original:


El código se muestra a continuación:

#!/usr/bin/env python

#Se importa Image de SimpleCV

from SimpleCV import Image

#Se crea la instancia Imagen tomando la imagen

#imagen1.png

imagen = Image('imagen1.png')




#Se ejecuta binarize a la imagen

#sin argumentos.

imgBin = imagen.binarize()

#Se salva la imagen como resultado3.jpg

imgBin.save("resultado.jpg")

La imagen generada se muestra a continuación:


29 jul. 2012

Tutorial de PyQt. Desarrollo con QtDesigner. Parte 11.

Para repasar los artículos sobre pyQt pueden revisar el siguiente enlace.

En este caso en vez de escribir todo el código de la intefaz gráfica se usará la herramienta QtDesigner.

Se pedirá el nombre de la persona y al darle clip al botón Aplicar se mostrará el nombre colocado en la entrada de datos en la etiqueta, se tiene un segundo botón el cual termina la ejecución de la aplicación al darle clip.

La siguiente figura muestra el diseño de la interfaz:

La siguiente figura muestra la relación entre los botones y señales:

A cada botón se le asocia una función como lo muestra las siguientes dos figuras:
Botón Salir:

Botón Aplicar:

Al salvar la interfaz gráfica con nombre prueba3.ui lo que se hará a continuación es generar el código python por medio del comando:
pyuic4 -x prueba3.ui -o prueba3.py

El código generado se muestra a continuación:

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




# Form implementation generated from reading ui file 'prueba3.ui'

#

# Created: Sun Jul 29 22:49:50 2012

#      by: PyQt4 UI code generator 4.9.1

#

# WARNING! All changes made in this file will be lost!




from PyQt4 import QtCore, QtGui




try:

    _fromUtf8 = QtCore.QString.fromUtf8

except AttributeError:

    _fromUtf8 = lambda s: s




class Ui_Form(object):

    def setupUi(self, Form):

        Form.setObjectName(_fromUtf8("Form"))

        Form.resize(400, 300)

        self.pushButton = QtGui.QPushButton(Form)

        self.pushButton.setGeometry(QtCore.QRect(280, 260, 102, 28))

        self.pushButton.setObjectName(_fromUtf8("pushButton"))

        self.pushButton_2 = QtGui.QPushButton(Form)

        self.pushButton_2.setGeometry(QtCore.QRect(140, 260, 102, 28))

        self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))

        self.lineEdit = QtGui.QLineEdit(Form)

        self.lineEdit.setGeometry(QtCore.QRect(140, 40, 221, 28))

        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))

        self.label = QtGui.QLabel(Form)

        self.label.setGeometry(QtCore.QRect(20, 40, 69, 18))

        self.label.setObjectName(_fromUtf8("label"))

        self.label_2 = QtGui.QLabel(Form)

        self.label_2.setGeometry(QtCore.QRect(20, 160, 81, 18))

        self.label_2.setObjectName(_fromUtf8("label_2"))

        self.label_3 = QtGui.QLabel(Form)

        self.label_3.setGeometry(QtCore.QRect(140, 160, 221, 18))

        self.label_3.setObjectName(_fromUtf8("label_3"))




        self.retranslateUi(Form)

        QtCore.QObject.connect(self.pushButton, QtCore.SIGNAL(_fromUtf8("clicked()")), Form.close)

        QtCore.QObject.connect(self.pushButton_2, QtCore.SIGNAL(_fromUtf8("clicked()")), self.label_3.update)

        QtCore.QMetaObject.connectSlotsByName(Form)




    def retranslateUi(self, Form):

        Form.setWindowTitle(QtGui.QApplication.translate("Form", "Prueba", None, QtGui.QApplication.UnicodeUTF8))

        self.pushButton.setText(QtGui.QApplication.translate("Form", "Salir", None, QtGui.QApplication.UnicodeUTF8))

        self.pushButton_2.setText(QtGui.QApplication.translate("Form", "Aplicar", None, QtGui.QApplication.UnicodeUTF8))

        self.label.setText(QtGui.QApplication.translate("Form", "Nombre:", None, QtGui.QApplication.UnicodeUTF8))

        self.label_2.setText(QtGui.QApplication.translate("Form", "Resultado:", None, QtGui.QApplication.UnicodeUTF8))

        self.label_3.setText(QtGui.QApplication.translate("Form", "Texto", None, QtGui.QApplication.UnicodeUTF8))







if __name__ == "__main__":

    import sys

    app = QtGui.QApplication(sys.argv)

    Form = QtGui.QWidget()

    ui = Ui_Form()

    ui.setupUi(Form)

    Form.show()

    sys.exit(app.exec_())

Se resalta en color azul la relación de ambos botones (Salir y Aplicar) con los eventos (Form.close y label_3.update).

El cambio en el código que se tiene que hacer es crear un método en la clase creada que toma el contenido del widget lineEdit y se la pasa a label_3, se muestra en la consola por medio de print y en la etiqueta por el método set de la etiqueta.

A continuación el código modificado con las secciones en azul que muestra lo explicado antes:

#!/usr/bin/env python

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




# Form implementation generated from reading ui file 'prueba3.ui'

#

# Created: Sun Jul 29 22:27:29 2012

#      by: PyQt4 UI code generator 4.9.1

#

# WARNING! All changes made in this file will be lost!




from PyQt4 import QtCore, QtGui




try:

    _fromUtf8 = QtCore.QString.fromUtf8

except AttributeError:

    _fromUtf8 = lambda s: s




class Ui_Form(object):

    

    def Actualizar(self):

        texto = self.lineEdit.text()

        print texto

        self.label_3.setText(texto)

    

    def setupUi(self, Form):

        Form.setObjectName(_fromUtf8("Form"))

        Form.resize(400, 300)

        self.pushButton = QtGui.QPushButton(Form)

        self.pushButton.setGeometry(QtCore.QRect(280, 260, 102, 28))

        self.pushButton.setObjectName(_fromUtf8("pushButton"))

        self.pushButton_2 = QtGui.QPushButton(Form)

        self.pushButton_2.setGeometry(QtCore.QRect(140, 260, 102, 28))

        self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))

        self.lineEdit = QtGui.QLineEdit(Form)

        self.lineEdit.setGeometry(QtCore.QRect(140, 40, 221, 28))

        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))

        self.label = QtGui.QLabel(Form)

        self.label.setGeometry(QtCore.QRect(20, 40, 69, 18))

        self.label.setObjectName(_fromUtf8("label"))

        self.label_2 = QtGui.QLabel(Form)

        self.label_2.setGeometry(QtCore.QRect(20, 160, 81, 18))

        self.label_2.setObjectName(_fromUtf8("label_2"))

        self.label_3 = QtGui.QLabel(Form)

        self.label_3.setGeometry(QtCore.QRect(140, 160, 221, 18))

        self.label_3.setObjectName(_fromUtf8("label_3"))




        self.retranslateUi(Form)

        QtCore.QObject.connect(self.pushButton, QtCore.SIGNAL(_fromUtf8("clicked()")), Form.close)

        QtCore.QObject.connect(self.pushButton_2, QtCore.SIGNAL(_fromUtf8("clicked()")), self.Actualizar)

        QtCore.QMetaObject.connectSlotsByName(Form)




    def retranslateUi(self, Form):

        Form.setWindowTitle(QtGui.QApplication.translate("Form", "Prueba", None, QtGui.QApplication.UnicodeUTF8))

        self.pushButton.setText(QtGui.QApplication.translate("Form", "Salir", None, QtGui.QApplication.UnicodeUTF8))

        self.pushButton_2.setText(QtGui.QApplication.translate("Form", "Aplicar", None, QtGui.QApplication.UnicodeUTF8))

        self.label.setText(QtGui.QApplication.translate("Form", "Nombre:", None, QtGui.QApplication.UnicodeUTF8))

        self.label_2.setText(QtGui.QApplication.translate("Form", "Resultado:", None, QtGui.QApplication.UnicodeUTF8))

        self.label_3.setText(QtGui.QApplication.translate("Form", "Texto", None, QtGui.QApplication.UnicodeUTF8))







if __name__ == "__main__":

    import sys

    app = QtGui.QApplication(sys.argv)

    Form = QtGui.QWidget()

    ui = Ui_Form()

    ui.setupUi(Form)

    Form.show()

    sys.exit(app.exec_())



A continuación se muestra la figura de la ejecución de la aplicación luego de capturar y mostrar la información del widget LineEdit:

19 jul. 2012

Ejecutar una tarea en una fecha próxima (APScheduler)

En el artículo anterior se explica 2 formas de definir tareas  de forma periódica y al estilo crond. En este caso se explicará como ejecutar una función en una fecha próxima.


#!/usr/bin/env python
#Se importa date
from datetime import date
#Se importa Scheduler
from apscheduler.scheduler import Scheduler
#Se importa sleep
from time import sleep

# Se instancia la clase scheduler
sched = Scheduler()
#Se inicia el scheduler
sched.start()

# Se define la función a ser ejecutada.
#La función toma un texto y lo presenta en pantalla.
def Tarea(texto):
    print texto

# La tarea será ejecutada el 19 de Julio de 2012.
fecha_ejecucion = date(2012, 07, 19)

# se alamacena la tarea en la variable tarea en caso que se quiera suspender
#Se le pasa la función Tarea, la fecha a ejecutar y los argumentos solicitados de la función
tarea = sched.add_date_job(Tarea, fecha_ejecucion, ['texto a escribir'])


#Se muestra las tareas definidas.
print sched.print_jobs()
#Se crea un ciclo de 10 iteraciones
#Donde se espera 60 minutos por cada iteracion
#Se muestra en pantalla las veces que se ejecuta.
for i in range(10):
    print "---- %s" %i
    sleep(3600)
#Se detiene el scheduler
sched.shutdown(wait=False)

Al ejecutar el programa se muestra lo siguiente:


ernesto@clara:~/bin/python/procesos$ sudo ./procesos3.py

Jobstore default:

    Tarea (trigger: date[2012-07-19 00:00:00], next run at: 2012-07-19 00:00:00)

None

---- 0

---- 1

text

---- 2

---- 3

---- 4

---- 5

---- 6

---- 7

---- 8

---- 9


Con este artículo se muestra las tres formas de ejecutar procesos con APScheduler (ejecución periódica, estilo crond y ejecución en una fecha próxima).

18 jul. 2012

Agendar tareas con python

En Linux se pueden ejecutar procesos de forma periodica gracias a cron o en un momento determinado gracias a at.

En python se tiene una librería que permite ejecutar de forma periodica o en una fecha determinada al estilo de cron o at, la librería se llama APScheduler (Advanced Python Scheduler). La documentación de SPScheduler lo pueden revisar en este enlace.

El ejemplo a mostrar a continuación permite ejecutar 2 tareas, la primera tarea se ejecuta a intervalos de 1 minuto, la segunda tarea se ejecuta de lunes a viernes en una hora específica.

El código del ejemplo se muestra a continuación:

#!/usr/bin/env python

#Se importa Scheduler

from apscheduler.scheduler import Scheduler




#Se importa ctime y sleep

from time import ctime,sleep




#Se crea la instancia de la clase Scheduler

sched = Scheduler()




#Se crea una funcion con la tarea1, pero se dfine

#un decorador para la tarea para que sea periodica

#Cada minuto se ejecutara la tarea.

@sched.interval_schedule(minutes=1)

def Tarea1():

    #Muestra en pantalla la fecha y hora

    print "Se ejecuta cada minuto: %s" %ctime()




#Se crea la tarea2 al estilo cron por medio de un decorador cron

#que se ejecuta de lunes a viernes a las 9:40pm.

@sched.cron_schedule(day_of_week='mon-fri', hour=21,minute=30)

def Tarea2():

    #Se muestra en pantalla la hora del momento que se ejecuta la aplicacion.

    print "Se ejecuto a las : %s" %ctime()







    

#Se pasa la configuracion al scheduler

sched.configure()

#Se inicia el scheduler

sched.start()




#Se muestra las tareas definidas.

print sched.print_jobs()

#Se crea un ciclo de 10 iteraciones

#Donde se espera un minuto por cada iteracion

#Se muestra en pantalla las veces que se ejecuta.

for i in range(10):

    print "---- %s" %i

    sleep(60)

    

#Se detiene las tareas del scheduler al finalizar

#las iteraciones

sched.shutdown(wait=False)

La salida de la ejecución del programa se muestra a continuación:


ernesto@clara:~/bin/python/procesos$ sudo ./procesos2.py 

Jobstore default:

    Tarea1 (trigger: interval[0:01:00], next run at: 2012-07-18 21:27:59.911483)

    Tarea2 (trigger: cron[day_of_week='mon-fri', hour='21', minute='30'], next run at: 2012-07-18 21:30:00)

None

---- 0

Se ejecuta cada minuto: Wed Jul 18 21:27:59 2012

---- 1

Se ejecuta cada minuto: Wed Jul 18 21:28:59 2012

---- 2

Se ejecuta cada minuto: Wed Jul 18 21:29:59 2012

Se ejecuto a las : Wed Jul 18 21:30:00 2012

---- 3

Se ejecuta cada minuto: Wed Jul 18 21:30:59 2012

---- 4

Se ejecuta cada minuto: Wed Jul 18 21:31:59 2012

---- 5

Se ejecuta cada minuto: Wed Jul 18 21:32:59 2012

---- 6

Se ejecuta cada minuto: Wed Jul 18 21:33:59 2012

---- 7

Se ejecuta cada minuto: Wed Jul 18 21:34:59 2012

---- 8

Se ejecuta cada minuto: Wed Jul 18 21:35:59 2012

---- 9

Se ejecuta cada minuto: Wed Jul 18 21:36:59 2012

Con está librería se puede definir la ejecución de procesos a ciertos días y horas, o de forma periódica.

15 jul. 2012

Desplegar información vía web con Django. Parte 3.

En el artículo anterior se explico como mostrar un resultado en una página web por medio de Django, ahora se mostrará una serie de información como página html normal y luego usando las plantillas de Django.

La idea es desplegar una serie de actividades mostrando el nivel de prioridad que tiene cada actividad.

Se tiene la vista (views.py) con la función Actividades, esta función retorna un código html con la lista de actividades y su prioridad. Es necesario modificar el archivo urls.py para cuando se coloque el url que se desea visitar (en este caso asociada a actividades), este devuelva el resultado de la función Actividades del archivo views.py.

El código del archivo views.py se muestra a continuación:
from django.http import HttpResponse



def Actividades(request):

    return HttpResponse("""

                        <html>

                        <head>

                        <title>Lista de actividades</title>

                        </head>

                        <body>

                        <h1>Actividades:</h1>

                        <li>Comprar comida</li>

                        <li>Preparar articulo</li>

                        <li>Trotar</li>

                        <li>Reunion para proyecto pysms</li>

                        </body></html>""")

El código del archivo urls.py se muestra a continuación:

from django.conf.urls import patterns, include, url




import todo.views




urlpatterns = patterns('',

    url(r'^actividades/',todo.views.Actividades),

)

Al visitar el url http://127.0.0.1:8080/actividades se muestra la página como aparece en la siguiente figura:



Ahora en vez de insertar código html en la vista se usará plantillas, para ello se crea una función Actividades1 en la vista donde se crea una lista de diccionarios con la información de la actividad y su prioridad,  se carga la plantilla index.html, se crea el contexto donde se le pasa la lista de diccionarios de las actividades y se retorna la respuesta HTTP por medio de la plantilla haciendo render del contexto.

A continuación se muestra el código del archivo views.py:

# Create your views here.

from django.http import HttpResponse

from django.template import Context, loader




def Actividades(request):

    return HttpResponse("""

                        <html>

                        <head>

                        <title>Lista de actividades</title>

                        </head>

                        <body>

                        <h1>Actividades:</h1>

                        <li>Comprar comida</li>

                        <li>Preparar articulo</li>

                        <li>Trotar</li>

                        <li>Reunion para proyecto pysms</li>

                        </body></html>""")







def Actividades1(request):

    #Se genera la lista de diccionarios con las actividades y su importancia

    actividades = [{'titulo':'Comprar comida','importancia':'baja'},

        {'titulo':'Preparar articulo','importancia':'media'},

        {'titulo':'Trotar','importancia':'alta'},

        {'titulo':'Reunion para proyecto Pysms','importancia':'muy alta'}]

    #Se carga el archivo con la plantilla html

    t = loader.get_template('index.html')

    #Se carga el contexto de las actividades

    c = Context({'actividades': actividades,})

    #Se envia la respuesta renderizando el contexto a la plantilla

    return HttpResponse(t.render(c))



Ahora se agrega una nueva línea al archivo urls.py donde aparece la redirección a actividades1 que usa la función de la vista (views.py) Actividades1:

from django.conf.urls import patterns, include, url

import todo.views




urlpatterns = patterns('',

    url(r'^actividades/',todo.views.Actividades),

    url(r'^actividades1/',todo.views.Actividades1),

)

Ahora se creará un directorio llamado plantillas dentro de la aplicación pruebas del proyecto pruebas, dentro de ese directorio se crea el archivo index.html con el siguiente contenido:


<html>

    <head>

        <title>Lista de actividades</title>

        <style type="text/css">

             body { font-family: Arial, Helvetica, sans-serif;color: black;background: #ffffff; }

        </style>




    </head>

    <body>

        <h1>Actividades:</h1>

            {% if actividades %}

            <table border="1">

            {% for actividad in actividades %}

            <tr><td>{{actividad.titulo}}</td>

            <td>{{actividad.importancia}}</td></tr>

            {% endfor %}

            </table>

            {% else %}

            <p>No hay actividades que hacer!</p>

            {% endif %}

    </body>

</html>



Al salvar el archivo se inicia el servidor de django (python manage.py runserver 8080) y aparece lo siguiente al navegar a http://localhost:8080/actividades1/ :

La aplicación dice que la plantilla no existe, claro falto modificar el archivo settings.py para que busque la plantilla en la ruta donde se encuentra:

El archivo settings.py debe tener la ruta donde se guardará las plantillas, la configuración de la sección templates se muestra a continuación:

TEMPLATE_DIRS = (

    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".

    # Always use forward slashes, even on Windows.

    # Don't forget to use absolute paths, not relative paths.

    '/home/ernesto/django/pruebas/pruebas/pruebas/plantillas/'

)

Luego al iniciar el servidor web de Django se obtiene el resultado de la lista de actividades con sus prioridades:

Pueden bajar el archivo comprimido del código en este enlace.

8 jul. 2012

Captura de imágen desde webcam con el framework SimpleCV. Parte 2.

En el artículo anterior se explica como usar la webcam del equipo para capturar una imágen, en este caso se explicará como definir el tamaño de la imágen, ahora se muestra como manejar 2 webcam al mismo tiempo.

La idea es capturar imágenes de ambas webcam y luego salvarlas en formato png.

El código de la aplicación es la siguiente:

#!/usr/bin/env python




#Importa Camera de SimpleCV

from SimpleCV import Camera

#Se importa sleep de time

from time import sleep

# Se asocia la primera camara con un ancho y alto predefinido.

camara1 = Camera(0,{ "width": 640, "height": 480 })

# Se asocia la segunda camara

camara2 = Camera(1)

# Se captura la imagen de la primera camara y segunda camara

imagen1 = camara1.getImage()

imagen2 = camara2.getImage()

#Se escribe un texto en la primera camara con la posicion dentro de la

#imagen donde va a estar.

imagen1.drawText("Camara 1",160, 120)

#Se escribe un texto en la segunda camara

imagen2.drawText("Camara 2")

#Se muestra ambas imagenes

imagen1.show()

imagen2.show()

#Se salva ambas imagenes

imagen1.save("imagen1.png")

imagen2.save("imagen2.png")

A continuación se muestra las imágenes capturadas por las 2 webcam:
Webcam 1:
Webcam 2:

Captura de imágen desde la webcam con el framework SimpleCV. Parte 1.

SimpleCV es una framework para la construcción de aplicaciones de Visión por el computadort "Computer Vision", es un conjunto de librerias que permiten capturar imágenes por medio de camaras (webcam) o camaras IP para obtener información a partir de dichas imágenes.

La página del proyecto SimpleCV se puede visitar desde este enlace.

Para instalar SimpleCV se usará las herramientas de instalación de python easy_install o pip.
pip install simplecv

El ejemplo que se desarrollará es una simple aplicación que capture la imágen de la webcam, la presente en pantalla por unos segundos y la salve en un archivo con formato png.

El código es el siguiente:


#!/usr/bin/env python




#Importar los modulos Camera, Display e Image.

from SimpleCV import Camera, Display, Image

#Se importa sleep para darle unos segundos a la 

#aplicacion a que muestra la captura en pantalla.

from time import sleep

#Se crea una instancia de Camera.

#Se inicializa la camara

camara = Camera()




#Se crea una instancia de Display

#se inicializa display

pantalla = Display()




#Se captura una imagen usando la camara

imagen = camara.getImage()




#Muestra la imagen en pantalla

imagen.save(pantalla)




#Se salva la imagen en un archivo

imagen.save("captura.png")

sleep(2)

Al ejecutar el programa se muestra una pantalla con la captura que hace la webcam y la guarda en un archivo.
A continuación se muestra la imágen capturada:

7 jul. 2012

Hola Mundo con Django. Parte 2.

En el artículo de Framework de desarrollo web con Django parte 1 se explica como instalar Django e iniciar el servidor web que viene incorporado para realizar pruebas del desarrollo.

Ahora se explicará como mostrar una página web con un mensaje "Hola Mundo".

Dentro del directorio pruebas del proyecto pruebas creado en el artículo anterior se crea una aplicación, La aplicación se llamará todo:


python manage.py startapp todo

Este comando crea el directorio todo. Dentro de ese directorio encontrarán los siguientes archivos:
1. __init__.py: Específica a python que el contenido del directorio es un paquete.
2. models.py: Modelo de datos para la base de datos usando un ORM.
3. tests.py:  Define las pruebas unitarias.
4. views.py:  Se crean las vistas de la aplicación por medio de funciones.

En el archivo views.py se crea una función donde devuelve un string como respuesta para la página web:
#Se importa HttpResponse, la cual será usado para devolver una respuesta http.



from django.http import HttpResponse




#Se crea la función HolaMundo, se le pasa como argumento request.

def HolaMundo(request):

#Se devuelve una respuesta http pasando el string que se quiere que 

#aparezca en la página web.

    return HttpResponse("Hola Mundo!")

Ahora que se creo la función en el archivo de vistas, se hace necesario definir el URL donde se podrá ver la página de la vista.

Para visualizar la pagina se crea una línea en el archivo urls.py del proyecto donde se define la expresión regular del url que se desea mostrar la página, luego se coloca la ruta de la función del archivo views.py donde se devuelve el string que se va a mostrar en la página.

El archivo urls.py contiene lo siguiente:


#Se importa  patterns y url.

from django.conf.urls import patterns,  url

#Se importa la vista de la aplicación todo.

import todo.views

#Se define la tupla de patterns donde se lista los urls a desplegar.

#Se busca que el url tenga el patrón /hola, y se ejecuta HolaMundo del archivo views.py.

urlpatterns = patterns('',

    url(r'^hola/',todo.views.HolaMundo),




)


Se ejecuta el servidor de django:
python manage.py runserver 8080

La figura muestra el resultado de abrir el url http://127.0.0.1:8080/hola/





6 jul. 2012

Framework de desarrollo web Django. Parte 1.

Django es un framework de desarrollo web hecho en python que usa el paradigma MTV, Modelo, template (plantilla) y Vista.

Para instalar django en Debian se puede hacer con apt-get:
apt-get install python-django

Si se desea instalar la última versión de Django se puede hacer con easy_install o por pip:
easy_install django
ó
pip install django

Luego de instalado django se procede a crear un proyecto:
django-admin startproject pruebas

Se crea el directorio pruebas.

Dentro de dicho directorio se tiene lo siguiente:
1. manage.py : Interfaz de línea de comando para las aplicaciones.
2. pruebas: Directorio del proyecto.

Dentro del directorio se tiene lo siguiente:
1. __init__.py  : Define que es un paquete python.
2. settings.py   : Archivo de configuración específico del proyecto.
3. urls.py         : Configuración global de URLs.
4. wsgi.py        : Configuración de WSGI para el proyecto pruebas.

El archivo settings.py contiene lo siguiente:


Habilita el modo debug para la aplicación web y la plantilla:

DEBUG = True
TEMPLATE_DEBUG = DEBUG

Se define el admin del proyecto:
ADMINS = (
    ('Ernesto Nadir Crespo Avila', 'ecrespo@gmail.com'),
)

Se define la base de datos a utilizar (se  puede utilizar, mysql, postgresql, sqlite3 u oracle, con alguna extensión se puede usar mongodb ), con la configuración necesaria para conectarse a dicha base de datos:
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': '',                      # Or path to database file if using sqlite3.
        'USER': '',                      # Not used with sqlite3.
        'PASSWORD': '',                  # Not used with sqlite3.
        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}


Se define la zona horaria:
TIME_ZONE = 'America/Caracas'

Se define el idioma de la aplicación:
LANGUAGE_CODE = 'es-ve'


En otro artículo se continuará con la explicación de las opciones que tiene el archivo de configuración del proyecto en django.

Para iniciar el servidor de pruebas se ejecuta el siguiente comando:

Para iniciar un servidor web local.
python manage.py runserver 127.0.0.1

Si se desea usar una IP y un puerto específico.
python manage.py runserver ip:puerto


La figura muestra el servidor de pruebas de django en funcionamiento:

La siguiente figura muestra la página de inicio del servidor django en el navegador:


2 jul. 2012

Tutorial de ZeroMQ con Python. Parte 8.

Este artículo muestra el uso del patrón PUB/SUB como en el artículo de zeroMQ parte 4.

La diferencia está en la definición del transporte, en la parte 4 se usa tcp y en este caso se usará epgm que se usa para multicast.

El ejemplo que se mostrará se basa en el artículo de Saghul Ibarra en su blog.
El productor crea una línea de comandos donde se pasa el texto al consumidor, el consumidor recibe el texto y sólo se muestra en pantalla el texto que está definido en la subscripción.

En el productor se define unas opciones en el socket, en el sitio de ZeroMQ tiene una explicación de las opciones para crear el socket. LINGER con parámetro cero define que se descarte mensajes que no son enviados.

El código del productor se muestra a continuación:

#!/usr/bin/env python



# producer

#Se importa ZeroMQ

import zmq

#Se crea la instancia de la clase Context.

context = zmq.Context()

#Se define el socket con parametro PUB

socket = context.socket(zmq.PUB)

#Se define unas opciones en el socket

#esta opcion LINGER con valor cero, descarta mensajes no enviados

socket.setsockopt(zmq.LINGER, 0)    




#Se conecta al socket a la IP y puerto

#por medio de multicast

socket.connect('epgm://192.168.10.96:5000')







#Se crea un ciclo

#si se envia el texto salir, se envia y luego finaliza el ciclo

#si no, se envia el texto

while True:

 mensaje = raw_input("->")

 print mensaje

 socket.send(mensaje)

 if mensaje == "salir": break

  

socket.close()

El código del programa consumidor es el siguiente:

#!/usr/bin/env python
#Importar zeroMQ
import zmq
#Se crea la instancia de la clase contexto
context = zmq.Context()
#Se define el socket con parametro SUB
socket = context.socket(zmq.SUB)
#Se conecta el socket a la IP y puerto del productor
#con el transporte epgm
socket.connect('epgm://192.168.10.96:5000')
#Se define los textos que se recibe la informacion.
#prueba, hora y salir.
socket.setsockopt(zmq.SUBSCRIBE, 'prueba')
socket.setsockopt(zmq.SUBSCRIBE, 'hora')
socket.setsockopt(zmq.SUBSCRIBE, 'salir')
#Se define un ciclo,
#se recibe la informacion
#Si el texto es salir se muestra en pantalla 
#finaliza el ciclo, si no se muestra
#el texto en pantalla
while True:
    rcv = socket.recv()
    print rcv
    if rcv == "salir": break
 
Las siguientes figuras muestran el resultado de la ejecución de ambos programas:
Productor:

Consumidor: