El taller Linux Pinar


El portal Linux Pinar continua creciendo en información, estamos estrenando la sección El Taller, un espacio donde usted pordrá enrriquecer sus conocimientos del mundo Linux.

Esta sección tiene como objetivos liberar semanalmente una serie de talleres que abarcarán temas de programación, software libre, etc… en este momento hemos comenzado con el taller de Python y Django con los dos primerosencuentros de cada uno, estos serán publicados como se dijo anteriormente con una frecuencia semanal los jueves y viernes de cada semana.

La url del taller es: http://www.pri.jovenclub.cu/jc/linux/taller/, a la derecha pueden ver las temáticas de cada uno.

Próximamente continuaremos con dos talleres más, HTML y Buenas Prácticas en la Migración hacia el Software Libre.

Participa y dejanos tu opinión en los comentarios.

Anuncios

Configurar CVS para el control y desarrollo de Proyectos


Hola!!!

Siempre me pregntaba como un grupo de programadores juntaban todo el codigo mientras desarrollaban una aplicacion.

Bueno, ayer un colega y yo comenzamos a realizar un proyecto en Django y nos pruntamos como hacerlo, investigamos un poco por la red y rapido encontramos a CVS. Esto nos permitiría implementar un sistema de control de versiones: mantiener el registro de todo el trabajo y los cambios en los ficheros (código fuente principalmente) que forman el proyecto (de programa) y permite que distintos desarrolladores (potencialmente situados a gran distancia) colaboren.

Basicamente se utiliza en el desarrollo de un proyecto informatico para llevar un control de los ficheros del codigo y evitar por ejemplo que el codigo que escribe un usuario sea “machacado” con el codigo de otro usuario. Ademas con un sistema de control de versiones, el programador siempre puede disponer de la ultima version del codigo lo que ayuda a continuar con el desarrollo del proyecto.

Te pondre un ejemplo de para que sirve todo esto.

Imagina dos programadores que estan trabajando en el mismo proyecto, y casualmente ambos estan modificando el mismo fichero de codigo. Cuando uno de ellos actualice ese fichero en el repositorio se queda marcado, de tal manera que cuando el otro intente subir al repositorio de codigo ya ve, que ese fichero ha sufrido una modificacion desde la ultima vez que el se actualizo, lo que le obliga, a traerse de nuevo ese fichero (con los cambios que haya realizado el primer programador), añadir los suyos y volver a subir el fichero. Sin un mecanismo de control de versiones, ese cambio se perderia, el primer desarrollador subiria el fichero y el segundo subiria su version. Esto para un fichero es controlable, pero cuando tienes miles de ficheros y miles de lineas de codigo significa un desastre total. Por eso el control de versiones es necesario.

Para instalar el servidor y el cliente cvs ejecutamos:

sudo apt-get install cvs cvsd

En un momento determinado nos pedira la ruta para el repositorio, pon por ejemplo /cvsrepo. Este es el directorio a partir del cual se ira colgando todos aquellos modulos/proyectos que administremos con el CVS.

Este directorio lo vamos a definir a partir de /var/lib/cvsd, asi que realmente el path completo seria:

/var/lib/cvsd/cvsrepo

Ejecutamos las siguientes secuencias de comandos:

$ sudo cvsd-buildroot /var/lib/cvsd

Si la carpeta cvsrepo no existe, la creamos

$ cd /var/lib/cvsd
$ sudo mkdir cvsrepo

Le damos permisos sobre la carpeta al usuario cvsd

$ sudo chown -R cvsd:cvsd cvsrepo

Inicializamos el repositorio

$ sudo cvs -d /var/lib/cvsd/cvsrepo init

creamos un usuario cvs y le damos una password.

$ sudo cvsd-passwd /var/lib/cvsd/cvsrepo <username>

por ejemplo:

sudo cvsd-passwd /var/lib/cvsd/cvsrepo papo

Ahora editamos el fichero:

sudo vi /var/lib/cvsd/cvsrepo/CVSROOT/config

Cambiamos “#SystemAuto=no” a “#SystemAuto=yes”

Ya tenemos todo funcionando. Para comprobar que accedemos:

cvs -d :pserver:username@localhost:/cvsrepo login
cvs -d :pserver:username@localhost:/cvsrepo checkout .

Por ejemplo:

cvs -d :pserver:papo@localhost:/cvsrepo login

Seria adecuado exportar la variable CVSROOT del siguiente modo:

export CVSROOT=:pserver:papo@localhost:/cvsrepo

o el valor que fuera, de esta manera ya no necesitariamos especificarla cada vez que fueramos a usar un comando “cvs”.

Ahora podriamos logarnos con:

cvs login

y por ejemplo colocarnos en la carpeta (dentro) de un proyecto que quisieramos subir al CVS y ejecutar:

cvs import -m “ficheros iniciales” MiProyecto HEAD MAIN

Con esto importamos el proyecto a CVS

Ahora podemos usar algun cliente CVS para descargar el proyecto desde el repositorio, yo estoy usando Cervisia que se integra muy bien a Quanta.

Espero que esto les sea de ayuda.

Mañana comienza el sprit de Traducción de la Documentación de Django


Ya sólo quedan 1 día para que comience el sprint de traducción on-line de la documentación de Django al español. Para que no haya confusiones sobre cómo participar aqui les dejo este link, donde se esplica como participar.

http://django.es/blog/traducir-la-documentacion-de-django-al-espanol/

Los esperamos

Sprint de traducción y django.es


En la lista de correo de django-es el administrador del website español de django, Antonio Mele, ha lanzado una propuesta muy interesante, realizar un sprint-online para traducir la documentación actual de django, o por lo menos una gran parte.

Antonio también esta realizando una gran labor levantando la comunidad hispano con el site de django.es y su blog

Animo, vamos a participar todos y hacer q la documentacion de Django este disponible para todos los hispanos…

Linvix

Correr Varias Instancias de Django en el mismo servidor Apache


Esta experiencia la viví ayer, claro que no es nada del otro mundo pero es algo que una ves intenté hacer y no pude, siempre tuve la duda, hasta que ayer se me presentó el problema.

Necesitaba publicar dos sitios hechos con Django en el mismo servidor web, pero no podía usar VirtualHosting, los sitios se tenían que ver bajo las urls:

1. http://midominio.com/sitios/sitiouno/

2. http://midominio.com/sitios/sitiodos/
Inicialmente tenia a /sitiouno/ publicado con la siguiente configuración:

<Location “/sitios/sitiouno/”>
SetHandler python-program
PythonHandler django.core.handlers.modpython
PythonPath “[‘/var/www/sitios-‘] + sys.path”
SetEnv DJANGO_SETTINGS_MODULE sitiouno.settings
PythonAutoReload On
</Location>

#Esta parte es el directorio de las imagenes….
<Location “/jc/vi/cave/imagenes/”>
SetHandler None
</Location>
<LocationMatch “\.(jpg|gif|png)$”>
SetHandler None
</LocationMatch>

Cuando publiqué /sitiodos/ con la misma configuración comenzaron a mezclarse los dos sitios y dar algunos errores  en el acceso de algunas urls. Comencé a leer el libro de Django y rápidamente encontré la solución, usar la directiva PythonInterpreter en cada directiva </Location> quedando el fichero de configuración de la siguiente forma:

<Location “/sitios/sitiouno/”>
SetHandler python-program
PythonHandler django.core.handlers.modpython
PythonPath “[‘/var/www/sitios/’] + sys.path”
SetEnv DJANGO_SETTINGS_MODULE sitiouno.settings
PythonInterpreter sitiouno
PythonAutoReload On
</Location>
……..

……..
<Location “/sitios/sitiodos/”>
SetHandler python-program
PythonHandler django.core.handlers.modpython
PythonPath “[‘/var/www/sitios/’] + sys.path”
SetEnv DJANGO_SETTINGS_MODULE sitodos.settings
PythonInterpreter sitiodos
PythonAutoReload On
</Location>
…..

……

De esta forma podemos correr varias instancias de Django bajo el mismo servidor Apache

Espero que esto sea de utilidad para todos, y como dije al principio, no es nada nuevo, pero quizas a alguien le resultó confuso la primera ves.

Paginación con Django


Introducción

Las tareas de paginación son unas de las mas tediosas a la hora de programar un sitio Web. Django incluye herramientas para hacer todo este trabajo de una forma fácil y rápida.

En el siguiente tutorial explicaré un método para realizar paginación de noticias en una aplicación Web.

Este ejemplo esta basado en la version de desarrollo de Django en la fecha de hoy (0.97)

Creando nuestra aplicación

Vamos a suponer que tenemos una aplicación de noticias, la cual posee un modelo para almacenar las mismas:

models.py:

from django.db import models

class Noticias(models.Model):
    Titulo = models.CharField(maxlength=100)
    Cuerpo = models.TextField()
    Fecha_pub = models.DateField('Fecha', auto_now_add=True)
    Imagen = models.ImageField(upload_to= "noticias/%Y/%m/%d", blank=True)

    class Admin:
	list_display = ('Titulo', 'Fecha_pub')

    def  __str__(self):
	return self.Titulo

Para paginar utilizaremos el siguiente módulo de Python el cual puede estar en la raíz de la aplicación y ser incluído en esta con su include correspondiente:

paginator.py

from django.core.paginator import ObjectPaginator, InvalidPage

def Paginador(request, modelo, paginas):
	result_list = Paginator(modelo, paginas)
	try:
		page = int(request.GET.get('page')); #Tomamos el valor de parametro page, usando GET
	except:
		page = 1
	if (page < result_list.page(page)):
		pagina = result_list.page(page)
		Contexto = {'modelo': pagina.object_list, #Asignamos registros de la pagina
			 'page': page, #Pagina Actual
			 'pages': result_list.num_pages, #Cantidad de Paginas
			 'has_next': pagina.has_next(), #True si hay proxima pagina
			 'has_prev': pagina.has_previous(), #true si hay Pagina anterior
			 'next_page': page+1, #Proxima pagina
			 'prev_page': page-1, #Pagina Anterior
			 }
		return Contexto

Este modulo recibe dos argumentos: 1 es un objeto request, 2 un modelo (tabla), en este caso el modelo de las noticias. Como podemos ver la variable resul_list almacenaría solo tres registros de la tabla. “Contexto“ es un diccionario con todos los que nos interesa para realizar el paginado en la plantilla HTML.

También necesitaremos otra pequeña plantilla:

pagination.html:

{% if paginator.has_prev %}
	<a href="/noticias/?page={{ paginator.prev_page }}"><</a>
{% else %}
{% endif %}
Página {{paginator.page}} de {{paginator.pages}}
{% if paginator.has_next %}
	<a href="/noticias/?page={{ paginator.next_page }}">></a>
{% else %}
{% endif %}

Esta plantilla la debemos incluir en la plantilla HTML en la cual realmente queremos realizar el paginado.
Por último la vista que queremos muestre las noticias paginadas debe quedar de la siguiente manera:

views.py:

# importamos el modulo Paginador
from proyecto.Paginador import Paginador

def index(request):
	noticias = Noticias.objects.all().order_by('-Fecha_pub')
	pag = Paginador(request, noticias)
	plantilla = loader.get_template('noticias/noticias_list.html')
	c = RequestContext(request, {'noticia_list': pag['modelo'],
				     'request': request,
				     'paginator': pag,
	return HttpResponse(plantilla.render(c))

La función index es una función común,

  • Primero ordenamos el módulo Noticias por fecha para que se muestren primero las últimas noticias.
  • pag es un objeto del tipo Paginador el cual recibe dos argumentos y devuelve un diccionario.
  • Posteriormente pasamos los datos a la plantilla noticias_list.html
  • pag[‘modelo’] es el modelo(tabla) noticias con solamente 3 registros. Los que necesitamos.
  • pag es un diccionario con todos los datos necesarios para paginar.

Hasta aquí esta pequeña guía sobre cómo paginar. Espero sea de utilidad al lector, me gustaría recibir algunas opiniones al respecto y de ser posible también sugerencias, esta guía está implementada aquí

Contador de visitantes


Introducción

En el siguiente ejemplo crearemos un contador de visitas para tener constancia de las visitas que nuestro sitio recibe. Asumiremos que el lector tiene Django instalado y configurado y que posee conocimientos mínimos sobre el mismo.

Aunque el lenguaje de plantillas de Django incorpora varias etiquetas y filtros, es posible que usted quiera escribir los suyos propios, y es fácil hacerlo.

Creando nuestro propio contador de visitas

Primero, debemos crea un paquete (directorio) “templatetags“ dentro del paquete de la aplicación apropiada. Debería estar en el mismo nivel que “models.py“, “views.py“, etc. Por ejemplo:

visitantes/
    models.py
    templatetags/
    views.py

Añadimos dos ficheros al paquete “templatetags“: un “__init__.py“ (para indicar a Python que es un módulo que contiene código de Python) y un fichero que contendrá las definiciones de sus etiquetas y filtros personalizados llamado “my_tags.py“ (puede nombrarse como usted lo desee) y añadimos lo siguiente a “my_tags.py“:

from django import template
register = template.Library()

def contador(request):
	if request.session.get('contador', False):
		contador = GetContador()
		return str(contador)
	request.session['contador'] = True
	contador = GetContador()
	contador = contador + 1
	SetContador(str(contador))
	return str(contador)
	
def GetContador():
	f_contador = open('/path/to/contador/contador', 'r') 
	contador = f_contador.read()
	return int(contador)

def SetContador(contador):
	'''Funcion que guarda la posición actual del visitante'''
	f_contador = open('/path/to/contador/contador', 'w')
	f_contador.write(contador)
	f_contador.close()

register.simple_tag(contador)

Explicación

  1. Para que sea una biblioteca de etiquetas válida, el módulo debe contener una variable llamada “register“ que sea una instancia de “template.Library“, en la que se registran todas las etiquetas y los filtros.
  2. Definimos la función contador que recibe el parámetro “request“.
  3. Comprobamos la sesión, esto es importante para que el contador no se aumente cuando recargamos la página. En este caso si la sesión existe el contador no se aumentará
  4. Obtenemos el valor del contador a través de la función “GetContador()“
  5. Retornamos el valor del Contador sin aumentar.
  6. Si la sesión no existe la creamos.
  7. Obtenemos el valor del contador a través de la función “GetContador()“
  8. Aumentamos el contador en 1.
  9. Guardamos el valor del contador aumentado en uno en el fichero a través de la función “SetContador()“
  10. Retornamos el valor del contador aumentado en 1.
  11. Definimos la función “GetContador()“
  12. Abrimos el fichero contador en modo sólo lectura.
  13. Leemos el contenido del fichero.
  14. Retornamos el valor
  15. Definimos la función “SetContador()“
  16. Abrimos el fichero contador en modo escritura para añadir el nuevo valor
  17. Escribimos el nuevo valor
  18. Por último cerramos el fichero.
  19. Para facilitar la creación de este tipo de etiquetas, Django proporciona una función de conveniencia, “simple_tag“. Esta función es un método de “django.template.Library“, que toma como argumento una función que a su vez acepta un argumento, la inserta en una función “render“, y la registra en el sistema de plantillas.

Debemos crear el fichero contador en la ubicación /path/to/contador/contador.
Ahora nos vamos a la plantilla donde queremos insertar el contador de vistas e insertamos lo siguiente al inicio de la plantilla:

{% load my_tags %}

La etiqueta {% load %} hace una búsqueda según la opción “INSTALLED_APPS“ y sólo permite la carga de bibliotecas de plantillas pertenecientes a aplicaciones instaladas. Esto es una medida de seguridad: le permite tener el código de muchas librerías de plantillas escritas en Python en un único computador sin habilitar a cada instalación de Django el acceso a todas ellas.
Posteriormente en de la misma plantilla anterior donde queremos que el contador sea visible insertamos lo siguiente:

...
...
<tr>
    <td>
    Visitante #: {% contador request %}
    </td>
</tr>
...
...

“contador“ es el nombre de la función que esta dentro de “my_tags.py“ y debe recibir un parámetro “(request)“ que debe ser pasado a la plantilla para comprobar la sesión y así el contador no será aumentado cuando se recargue la página.

Hasta aquí el contador de visita. No soy un experto en Django, quizás existan otros métodos más fáciles pero este ha sido el que he encontrado. Este contador esta implementado