joe di castro

Cambio de diseño

2011-12-16T00:00:00+01:00

Después de los ligeros cambios de diseño que introduje en el sitio la semana pasada he decidido ir un poco más allá y dar un giro completo al mismo, conservando la estructura (casi no he tocado el HTML), pero con un diseño más limpio y minimalista.

La idea principal es la de favorecer aún más la lectura del mismo y darle el protagonismo absoluto al contenido (en el diseño anterior ya tenia un gran peso), eliminando todos aquellos elementos superfluos que pueden entorpecer o distraer de la lectura del mismo. Por eso he realizado cambios en la tipografía, el fondo, la división gráfica de las secciones, los cuadros con fragmentos de código y he eliminado los enlaces e iconos de la parte inferior. Además he transformado la página de about me en la de entrada al sitio.

Motivos del cambio

Realmente los motivos que me han llevado a realizar el cambio son mi propia tendencia, y cada vez la de más gente, a leer los contenidos web de otra forma. Normalmente leo los articulos a través de un lector de feeds, como Google Reader o RSSOwl, donde el contenido está compuesto únicamente por el texto y las imágenes originales del mismo, sobre un diseño sencillo que nos elimina cualquier trazo del diseño original. Esto facilita la lectura y unifica el diseño de sitios muy dispares. Lo que nos libra además de tener que lidiar con diseños recargados de imágenes, iconos, enlaces y publicidad¹, centrándonos únicamente en lo que realmente importa: el contenido

Esta tendencia se ha acentuado últimamente con el éxito de servicios como los de Read It Later e Instapaper que nos permiten postergar para un momento más idóneo la lectura de aquello que nos interesa leer con calma. Además nos permite leer el contenido en formato "solo texto" y offline, sin tener que acceder al sitio original. Tal ha sido el éxito de estos servicios y tan clara la tendencia a emplear el modo texto de los mismos, que han surgido algunos nuevos servicios destinados precisamente a facilitar la lectura de cualquier contenido web. Los más destacados son Readability y Evernote Clearly. Personalmente, cuando visito una pagina que tiene un diseño algo cargado y me interesa leer su contenido, no me lo pienso dos veces; tecleo :rea ↹ ↵ en Pentadactyl y en par de segundos tengo el texto en Readability para leerlo tranquilamente sin distracciones.

Aunque realmente no me acaba de convencer el diseño último de ninguno de estos sitios, por eso es mi idea el proporcionar la mejor experiencia de lectura posible de mi sitio, sin tener que recurrir a servicios externos. Porque desde mi punto de vista "lo simple es bello" y "menos es más", eliminar lo superfluo, contribuye a mejorar la calidad del diseño.

Inspiración

Para el nuevo diseño, me he inspirado principalmente en los diseños de blogs en esta línea que más me gustan, como son los de Steve Losh, Armin Ronacher, el tema Manifest para Wordpress o algunos de los temas minimalistas más empleados en Tumblr.

Quizá lo más importante haya sido el cambio a una tipografía Serif, por ser más cómoda la lectura empleando la misma. Y también el haberme decidido a emplear una Web Font después de haberlas descartado inicialmente para el sitio, para las cabeceras. Al haber eliminado los iconos inferiores y depender de una hoja de estilo alojada externamente en los servidores de Google, apenas se ve afectada la velocidad de carga y el peso de la página.

CSS 3 para los bloques de código

Quizá lo más espectacular del cambio de diseño sea el nuevo aspecto que tienen ahora los bloques en los que se presentan los fragmentos de código, como el que sigue. Para poder verlos debidamente es necesario emplear una versión reciente del navegador web que permita HTML 5 y CSS 3.

Estas son las reglas CSS 3 que empleo para implementarlo:

.codehilite:before, .codehilite:after {
    content: " ";
    position: absolute;
    z-index: -1;
    transform: skew(-3deg,-2deg);
    -ms-transform: skew(-3deg,-2deg);
    -webkit-transform: skew(-3deg,-2deg);
    -o-transform: skew(-3deg,-2deg);
    -moz-transform: skew(-3deg,-2deg);
    bottom: 14px;
    left: 1px;
    box-shadow: 0px 15px 5px #aaa;
    height: 50px;
    max-width: 50%;
    width: 50%;
}

.codehilite:after {
    transform: skew(3deg,2deg);
    -ms-transform: skew(3deg,2deg);
    -webkit-transform: skew(3deg,2deg);
    -o-transform: skew(3deg,2deg);
    -moz-transform: skew(3deg,2deg);
    left: auto;
    right: 1px;
}

.codehilite {
    position: relative;
    padding: 1px;
    background: #fafafa;
    margin: 25px;
    box-shadow: 0px 0px 1px 1px #ccc;
}

Aunque desafortunadamente emplear la propiedad transform y sus equivalentes para cada familia de navegadores, provoca que no se valide por ahora correctamente como CSS 3 valido, ya que la propiedad aún está en proceso de estandarización.

Diseño antiguo

Por supuesto nunca llueve a gusto de todos y habrá quien prefiera el aspecto anterior de la página, pero sinceramente creo que esto nuevo diseño contribuye en gran manera a ayudar a "digerir" los "pequeños" artículos con los que suelo prodigarme. Para que quede como testigo del cambio, está imagen corresponde con el diseño que tenia anteriormente el blog:

Bueno, nos libra de "casi" toda la publicidad, algunos deberían aprender que incluir publicidad en los feeds es de bastante mal gusto. ↩

Convertir ficheros djvu a pdf en Linux

2011-12-03T00:00:00+01:00

Tengo por costumbre almacenar mis documentos escaneados en el formato djvu, que fue expresamente creado para esa tarea y que otorga la mejor calidad posible en el menor espacio. Es el formato perfecto para documentos complejos sobre los que no se va a realizar un OCR (aunque también lo soporta). Además es un formato abierto, por lo que nos garantiza que podrá seguir empleándose en un futuro. Pero a veces necesito compartir estos ficheros con otros y para evitarme problemas suelo convertirlos a un formato más conocido y difundido como PDF.

Para realizar esta conversión empleo desde hace años (la primera versión es del 2009) un sencillo script en python. Ahora que he necesitado una conversión masiva de documentos de un formato al otro, he modificado el script para hacer esto más sencillo y he decidido compartirlo con cualquiera que pueda necesitarlo.

Los requisitos previos

Está diseñado para funcionar en Linux y necesita de la instalación de dos pequeños programas que son los que realmente realizan la conversión. Estos dos programas son ddjvu y tiff2pdf. Además de tener instalado Python en una versión 2.7 o superior. Estos dos programas vienen en los repositorios de prácticamente todas las distribuciones importantes dentro de los paquetes djvulibre y libtiff.

En el caso de no tenerlos instalados, la instalación de los mismos es muy sencilla, para distribuciones basadas en Debian/Ubuntu:

$ apt-get install djvulibre-bin libtiff-tools

ddjvu nos extrae las páginas que conforman el documento .djvu a un archivo intermedio en formato .tiff y tiff2pdf nos lo convierte en .pdf.

Modo de empleo

Emplearlo es muy sencillo, como se puede ver en la ayuda del mismo:

$ djvu2pdf -h
usage: djvu2pdf [-h] [-d | -z] [-v] file [file ...]

Converts a djvu file into a pdf file

positional arguments:
  file           The djvu file

optional arguments:
  -h, --help     show this help message and exit
  -d             no compression. Best quality but big files.
  -z             zip compression. More quality, more size.
  -v, --version  show program's version number and exit

Básicamente llamandalo desde python y poniendo a continuación el nombre del fichero/s es lo único que necesitamos para ejecutarlo, por ejemplo:

$ ls
documento.djvu  documento_2.djvu
$ python djvu2pdf.py documento.djvu documento_2.djvu
$ ls
documento.djvu  documento.pdf  documento_2.djvu  documento_2.pdf

Opcionalmente tenemos las opciones -d y -z, que nos sirven para especificar si queremos no emplear compresión en el .pdf (por defecto emplea compresión jpeg) o emplear compresión zip, respectivamente. Si no empleamos compresión, la calidad final será la mejor posible, pero los archivos serán muy grandes. En cambio, empleando zip, tenemos unos ficheros ligeramente mayores a cambio de una calidad muy buena. Aunque la compresión zip puede dar problemas con algunos visores y lectores de ebooks.

El script, djvu2pdf.py

El contenido del scipt es el que sigue. Este está disponible, actualizado siempre a la última versión, en mi repositorio

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    djvu2pdf.py: Converts a .djvu file into a .pdf file
"""

#==============================================================================
# This Script does exactly as the description above says.
#==============================================================================

#==============================================================================
#    Copyright 2011 joe di castro <joe@joedicastro.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#==============================================================================

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "03/12/2011"
__version__ = "0.3"

try:
    import sys
    import os
    from argparse import ArgumentParser
    from subprocess import Popen, PIPE
except ImportError:
    # Checks the installation of the necessary python modules
    print((os.linesep * 2).join(["An error found importing one module:",
    str(sys.exc_info()[1]), "You need to install it", "Stopping..."]))
    sys.exit(-2)

def check_execs(*progs):
    """Check if the programs are installed, if not exit and report."""
    for prog in progs:
        try:
            Popen([prog, '--help'], stdout=PIPE, stderr=PIPE)
        except OSError:
            msg = 'The {0} program is necessary to run the script'.format(prog)
            sys.exit(msg)
    return

def arguments():
    """Defines the command line arguments for the script."""
    main_desc = """Converts a djvu file into a pdf file"""

    parser = ArgumentParser(description=main_desc)
    parser.add_argument("file", nargs="+", help="The djvu file")
    group = parser.add_mutually_exclusive_group()
    group.add_argument("-d", dest="qlty", action="store_const", const="-d",
                        help="no compression. Best quality but big files.")
    group.add_argument("-z", dest="qlty", action="store_const", const="-z",
                        help="zip compression. More quality, more size.")
    parser.add_argument("-v", "--version", action="version",
                        version="%(prog)s {0}".format(__version__),
                        help="show program's version number and exit")
    return parser

def process(command, fname):
    """Process the external commands and report the errors."""
    errors = Popen(command, stderr=PIPE).stderr.readlines()
    for line in errors:
        print("{0}: {1}".format(fname.upper(), line.rstrip(os.linesep)))

def main():
    """Main section."""
    args = arguments().parse_args()
    djvu_files = args.file

    for djvu in djvu_files:
        if not os.path.exists(djvu):
            print("ERROR: cannot open '{0}' (No such file)".format(djvu))
        else:
            djvu_filename = djvu.split(".djvu")[0]
            tiff = '{0}.tif'.format(djvu_filename)
            pdf = '{0}.pdf'.format(djvu_filename)
            process(['ddjvu', '-format=tiff', djvu, tiff], tiff)
            if os.path.exists(tiff):
                quality = args.qlty if args.qlty else "-j"
                process(['tiff2pdf', quality, '-o', pdf, tiff], pdf)
                os.remove(tiff)

if __name__ == "__main__":
    check_execs('ddjvu', 'tiff2pdf')
    main()

Productividad en el escritorio Linux: Xmonad

2011-11-26T00:00:00+01:00

xmonad es un Gestor de ventanas de mosaico, uno de los más empleados y de los más potentes. Después de haber probado varios (dwm, bluetile, wmii y el plugin Compiz Grid) llevo ya unos cuantos meses trabajando con él y posiblemente siga conmigo mucho, mucho tiempo. Una vez que trabajas con un tiling window manager es muy difícil que echarse atrás, volver a un gestor de ventanas flotantes tradicional es casi impensable. Probaré uno más, awesome, que promete mucho y solo si este logra convencerme del cambio, abandonaré Xmonad.

¿Pero que tiene de especial un twm como Xmonad para haber decidido abandonar la gestión de ventanas por defecto de Compiz, Gnome Shell, Unity, Kwin, etc y apostar por él? Cuando uno está cansado de perder el tiempo con maniobras y decisiones triviales -ajustar las ventanas en la pantalla, que si el navegador por aquí, que si este terminal por allá, etc y cambiando continuamente la mano del teclado al ratón y viceversa- pues entonces decides que hay que darle una oportunidad a un twm, que sea el gestor de ventanas quien haga el trabajo sucio por ti.

¿Y hasta que punto resuelve bien este problema un twm como Xmonad? En este vídeo de xmonad trabajando con mi configuración, uno se puede hacer una idea de lo que es capaz.

Esbozo de las posibilidades de un Tiling Window Manager como Xmonad trabajando conjuntamente con Gnome 3 y Unity 2D sobre un Ubuntu 11.10. Recomiendo ver en HD.

Xmonad no necesita de un entorno de escritorio para trabajar, se puede iniciar una sesión directamente en él, al igual que la mayoría de gestores de ventanas de mosaico y otros gestores de ventanas como OpenBox. En el vídeo se puede apreciar que lo estoy empleando conjuntamente con Unity, en concreto Unity 2D. Esto es así porque emplear Xmonad (u otro twm) de forma autónoma te obliga a montar una serie de servicios que vienen montados por defecto normalmente en un escritorio, como salvapantallas, fondo de pantalla, bandeja de sistema, gestor de red, notificaciones, control de volumen, soporte impresoras, etc. Como estoy contento con el funcionamiento en general de Gnome, lo mejor es no reinventar la rueda y aprovechar lo mejor de los dos mundos empleando ambos a la vez. Anteriormente con Gnome 2, lo tenia funcionando sin Unity, pero con Gnome 3 me encuentro con la desagradable situación de que Gnome classic (el fallback mode) tiene un panel que es un autentico desastre y que además no es redimensionable en altura (tiene 30px y yo lo quiero con 21px). Actualmente hay una forma de arreglar esto, pero de momento lo tengo montado todo con Unity 2D y no hecho nada en falta. Eso si, de Unity solo empleo el panel, el Global Menu y la base de Gnome 3, lo demás lo descarto. Resumiendo, que básicamente sustituyo metacity por xmonad.

Xmonad con Unity 2D

Aquí contaré como tengo configurado actualmente Xmonad con Ubuntu 11.10 (Oneiric Ocelot) y con Gnome 3 y el panel de Unity 2D (unity-2p-panel). Si alguien continua con Gnome 2D o alguna versión anterior de Ubuntu puede revisar este enlace, la base es muy parecida, y luego solo habría que aplicar mi configuración (u otra).

Lo primero que se necesita es instalar xmonad, que en Ubuntu viene siendo así:

$ sudo apt-get install xmonad

A continuación crearíamos un fichero ~/.xmonad/xmonad.hs de configuración básica

$ mkdir ~/.xmonad           # El carácter ~ se obtiene pulsando Alt Gr + 4
$ vi ~/.xmonad/xmonad.hs    # Puedes emplear gedit en vez de vi si lo prefieres

e incluiríamos lo siguiente dentro de él:

import XMonad
import XMonad.Config.Gnome

myManageHook = composeAll (
    [ manageHook gnomeConfig
    , className =? "Unity-2d-panel" --> doIgnore
    , className =? "Unity-2d-launcher" --> doFloat
    ])

main = xmonad gnomeConfig { manageHook = myManageHook }

Ahora tendríamos que recompilar Xmonad, es algo necesario cada vez que realizamos algún cambio en la configuración, pero es un proceso que no suele llevar más de 5 segundos (y Xmonad se puede reiniciar sin tener que cerrar la sesión):

$ xmonad --recompile

Lo siguiente es crear los ficheros necesarios para crear una nueva sesión de Gnome. Creamos primero el fichero que define nuestra nueva sesión:

$ sudo vi /usr/share/gnome-session/sessions/xmonad.session

y dentro añadimos esto:

[GNOME Session]
Name=Xmonad Unity 2D
RequiredComponents=gnome-settings-daemon;
RequiredProviders=windowmanager;panel;
DefaultProvider-windowmanager=xmonad
DefaultProvider-panel=unity-2d-panel

a continuación creamos el fichero que inicia esta sesión:

$ sudo vi /usr/share/xsessions/xmonad-unity-session.desktop

con este contenido:

[Desktop Entry]
Name=XMonad Unity 2D
Comment=Tiling window manager
TryExec=/usr/bin/gnome-session
Exec=gnome-session --session=xmonad
Type=XSession

Con esto estaría ya montada una sesión con la configuración por defecto de Xmonad funcionado sobre Gnome y empleando el panel de Unity 2D. Ahora solo tendrías que cerrar la sesión e iniciar la sesión con Xmonad Unity 2D.

Si queréis hacer alguna prueba con esta configuración básica por defecto, es mejor tener a mano una referencia con las combinaciones de teclas disponibles, aquí hay un mapa del teclado de referencia que será muy útil.

Mi configuración

Para poder emplear la configuración que se puede ver en el vídeo simplemente habría que editar el fichero ~/.xmonad/xmonad.hs y sustituir su contenido por el de mi fichero de configuración. El contenido del fichero lo incluyo al final del articulo para no entorpecer la lectura del mismo.

Atajos de teclado

Al comienzo del fichero enumero las combinaciones de teclas empleadas en mi configuración, que difieren de las combinaciones por defecto y se asemejan de algún modo a las que estaba habituado en Gnome y son más intuitivas para los que estamos acostumbrados a él. Aunque las que se emplean por defecto también me son muy familiares al estar basadas en parte en Vim. Voy a detallar algunas de estas combinaciones.

Lanzar aplicaciones

-- Win  +  Enter                   Terminal
-- Win  +  F1                      Nautilus
-- Win  +  F2                      Firefox                  (single instance)
-- Win  +  F3                      Thunderbird              (single instance)
-- Win  +  F4                      RSSOwl                   (single instance)
-- Win  +  F5                      Hotot                    (single instance)
-- Win  +  F6                      ncmpcpp  - MPD player
-- Win  +  F7                      taskwarrior               
-- Win  +  F8                      PAC                      (single instance)
-- Win  +  F9                      Aptana                   (single instance)
-- Win  +  F10                     Xmind                    (single instance)
-- Win  +  F11                     Dbeaver                  (single instance)
-- Win  +  F12                     VirtualBox               (single instance)

Lo primero que se puede ver es una serie de atajos para lanzar aplicaciones empleando la tecla Win más las teclas de función. La tecla Win (también llamada Super) es la tecla maestra por defecto de Xmonad (mod4Mask) y es la que se emplea en combinación con otras para realizar todo tipo de acciones. Estas combinaciones me permiten lanzar las aplicaciones que uso con más frecuencia con un par de teclas.

Algunas aparecen con la frase single instance entre paréntesis, esto quiere decir que de estas aplicaciones solamente se abrirá una ventana. De hecho, lo que ocurre si volvemos a pulsar la combinación de teclas que abre la aplicación (una vez que esta ya está abierta) es que en lugar de abrir una nueva, nos movemos a la ventana ya abierta, esté en el escritorio que esté. Lo que es muy útil para localizar la ventana de una de estas aplicaciones de forma inmediata.

Adicionalmente la combinación Alt + Enter nos permite abrir una ventana del terminal. En este caso lo tengo predeterminado para que abra una venta de terminator

Consola emergente

-- Win  +  Space                   Run or Raise Shell Prompt
-- Win  +  Shift   +  Space        Run Shell Prompt
-- Win  +  Control +  Space        Window Prompt

A continuación podemos ver las teclas dedicadas a la consola emergente inferior (al estilo de Guake, Yakuake o Tilda) y que según la combinación pulsada realizara una acción u otra. La consola cuenta con auto-completado de texto, con lo cual escribiendo las primeras letras se nos muestran todas las coincidencias disponibles, a través de las que podemos desplazarnos con el tabulador.

Win + Espacio nos despliega una consola que nos permite lanzar una aplicación de igual modo que los lanzadores gráficos. Si la aplicación ya se encuentra abierta, nos dirige a la ventana de la misma.
Win + Mayús + Espacio ejecuta el comando que escribamos. Similar a la ventana de ejecutar comando de Gnome (Alt + F2 en Gnome)
Win + Control + Espacio nos muestra las ventanas que están abiertas en ese momento. Seleccionando una nos envía directamente a ella. Gracias a esto, localizar una ventana abierta entre los múltiples escritorios es cuestión de segundos. Si conocemos el nombre de la ventana podemos filtrarla escribiendo las primeras letras con el teclado. Imagina una sesión en la que tenemos abiertas más de 10 aplicaciones en varios escritorios distintos, esto nos permite localizar una ventana en segundos, es muy útil.

Reiniciar Xmonad

Con la combinación Win + q lo que hacemos es reiniciar Xmonad sin necesidad de reiniciar la sesión. Esto es muy útil cuando introducimos cambios en la configuración, después de guardar el fichero y ejecutar xmonad --recompile en un terminal, pulsamos esta combinación y los cambios se reflejaran de forma inmediata.

Transparencias

Una de las carencias de Xmonad es que no incorpora un gestor de composición por lo que si queremos manejar transparencias en nuestros terminales, notificaciones, ventanas, etc, debemos emplear uno externo. Para esto empleo xcompmgr que funciona perfectamente y es muy ligero. Como aún conservo las otras sesiones de Ubuntu (Unity, Unity 2 D, Gnome Shell, etc) lo que hago para que solo se ejecute en la sesión de Xmonad Unity 2D es emplear este script bash:

#!/bin/bash

if [ $DESKTOP_SESSION = "xmonad-unity-session" ]; then
    xcompmgr -I1 -O1 -Ff;    
fi

Luego añado el script a las aplicaciones que se ejecutan al inicio de la sesión y listo.

Bandeja del sistema

Una de las carencias de Unity en la versión 11.10 es que no han incorporado una bandeja del sistema donde alojar los iconos de aplicaciones que aún no tienen soporte para los indicadores. Se supone que debería añadirlos de forma automática al panel, incluso hay una configuración a través de dconf para habilitar esto, pero no funciona para todas las aplicaciones. Para añadir un systray empleo un script parecido al anterior para lanzar la aplicación trayer en esta sesión.

#!/bin/bash

MYARGS="--edge top --widthtype request --transparent true --alpha 0 --distancefrom right --distance 1100 --height 24 --tint 0x4c4a44 --align right"

if [ $DESKTOP_SESSION = "xmonad-unity-session" ]; then
    sleep 24 && trayer $MYARGS;
fi

Como personalizar Xmonad: Haskell

El mayor inconveniente de Xmonad (y a la vez una de sus ventajas) es que la configuración es necesario hacerla a través del mismo lenguaje de programación en el que está creado: Haskell. Esto es una importante barrera de entrada para los que no conocen el lenguaje, yo incluido, pero a base de ir probando algunas de las configuraciones aportadas y el prueba y error, puedes salir del paso muy satisfactoriamente. Con un poco de práctica y estudiando un poco el lenguaje (que de entrada no es de los más fáciles de leer) y gracias a la documentación disponible, puedes conseguir exactamente lo que quieres. Y esa es precisamente también su mayor ventaja, que puedes llegar a un gran nivel de personalización si conoces Haskell. Además Haskell le proporciona una gran estabilidad y extensibilidad.

Afortunadamente hay varios recursos disponibles que nos hacen el trabajo más fácil, porque Xmonad está aceptablemente bien documentado (en Inglés).

Xmonad.hs

Este es mi mi fichero de configuración de Xmonad:

-- joe di castro's xmonad.hs
-- Based on rupa's xmonad.hs, https://github.com/rupa/xmonad

-- ===============================================================  KEY BINDINGS

------------------------------------------------- Launch (or Raise) Applications
-- Win  +  Enter                   Terminal
-- Win  +  F1                      Nautilus
-- Win  +  F2                      Firefox                  (single instance)
-- Win  +  F3                      Thunderbird              (single instance)
-- Win  +  F4                      RSSOwl                   (single instance)
-- Win  +  F5                      Hotot                    (single instance)
-- Win  +  F6                      ncmpcpp  - MPD player
-- Win  +  F7                      taskwarrior               
-- Win  +  F8                      PAC                      (single instance)
-- Win  +  F9                      Aptana                   (single instance)
-- Win  +  F10                     Xmind                    (single instance)
-- Win  +  F11                     Dbeaver                  (single instance)
-- Win  +  F12                     VirtualBox               (single instance)                                                             
----------------------------------------------------------- Shell/Window prompts
-- Win  +  Space                   Run or Raise Shell Prompt
-- Win  +  Shift   +  Space        Run Shell Prompt
-- Win  +  Control +  Space        Window Prompt
--------------------------------------------------------------------- Navigation
-- Win  +  [1..9]                  Switch to workspace N
-- Win  +  Shift   +  [1..9]       Move client to workspace N
-- Ctrl +  Alt     +  Left/Right   Previous/Next workspace
-- Alt  +  Tab                     Focus next window
-- Alt  +  Shift   +  Tab          Focus previous window
-------------------------------------------------------------- Window management
-- Win  +  Shift   +  Left         Move window to previous workspace
-- Win  +  Shift   +  Right        Move window to next workspace
-- Win  +  Control +  Left         Move window to previous empty workspace
-- Win  +  Control +  Right        Move window to next empty workspace
-- Ctrl +  Up/Down                 Move focused window up/down
-- Win  +  m                       Toggle focused window Full Screen
-- Win  +  n                       Refresh
-- Win  +  -                       Move focused windows to master area
-- Win  +  w  (or Alt + F4)        Close focused window
-- Win  +  t                       Back to tiling (unfloat floating window)
-- Win  +  Shift   +  t            Back All to tiling (unfloat ALL windows)
-------------------------------------------------------------  Layout management
-- Win  +  Tab                     Rotate layouts
-- Win  +  Left/Right              Shrink/Expand the master area
-- Win  +  Up/Down                 Mirror Shrink/expand
-- Win  +  ,/.                     Increment/Deincrement 1 window in master area
-- Win  +  f                       Hide/Unhide the gnome-panel/status bar
-- Win  +  Shift   +  n            Reset current workspace to main layout
------------------------------------------------------------------ Mosaic Layout
-- Win  +  a/z                     Taller/Wider
-- Win  +  Control +  n            Reset
------------------------------------------------------------------------- Others
-- Print Screen                    Capture screen
-- Win  +  q                       Restart XMonad
-- Win  +  Shift   +  q            Close gnome session dialog

-- ============================================================== MOUSE BINDINGS

-- Win  +  Button 1                Float Window and Move by dragging
-- Win  +  Button 2                Raise Window to the top
-- Win  +  Button 3                Float Window and Resize by dragging

import XMonad
import qualified XMonad.StackSet as W
import qualified Data.Map        as M
import Data.Monoid

import XMonad.Actions.CycleWS
import XMonad.Actions.FlexibleResize as Flex
import XMonad.Actions.SinkAll
import XMonad.Actions.UpdatePointer
import XMonad.Actions.WindowGo

import XMonad.Hooks.DynamicLog
import XMonad.Hooks.EwmhDesktops
import XMonad.Hooks.ManageDocks
import XMonad.Hooks.ManageHelpers

import XMonad.Layout.LayoutHints
import XMonad.Layout.NoBorders
import XMonad.Layout.ResizableTile
import XMonad.Layout.Tabbed
import XMonad.Layout.ToggleLayouts
import XMonad.Layout.WindowArranger
import XMonad.Layout.Mosaic

import XMonad.Prompt
import XMonad.Prompt.Input
import XMonad.Prompt.RunOrRaise
import XMonad.Prompt.Shell
import XMonad.Prompt.Window

import XMonad.Util.Run
import XMonad.Util.Scratchpad
import XMonad.Util.WorkspaceCompare
import XMonad.Util.XSelection

import XMonad.Config.Gnome

-- Mod4 is the Super / Windows key
winMask = mod4Mask
altMask = mod1Mask

-- key bindings
myKeys conf@(XConfig {XMonad.modMask = modMask}) = M.fromList $
    [ ((winMask,                    xK_Return   ), spawn $ XMonad.terminal conf)
    , ((winMask,                    xK_F1       ), spawn "nautilus ~")
    , ((winMask,                    xK_F2       ), runOrRaise "firefox" (className =? "Firefox"))
    , ((winMask,                    xK_F3       ), runOrRaise "thunderbird" (className =? "Thunderbird"))
    , ((winMask,                    xK_F4       ), runOrRaise "./rssowl/RSSOwl" (className =? "RSSOwl"))
    , ((winMask,                    xK_F5       ), runOrRaise "hotot" (className =? "Hotot"))
    , ((winMask,                    xK_F6       ), spawn "terminator -e ncmpcpp")
    , ((winMask,                    xK_F7       ), spawn "terminator -e 'task shell' -p task")    
    , ((winMask,                    xK_F8       ), runOrRaise "pac" (className =? "Pac"))        
    , ((winMask,                    xK_F9       ), runOrRaise "./Aptana Studio 3/AptanaStudio3" (className =? "Aptana Studio 3"))            
    , ((winMask,                    xK_F10      ), runOrRaise "/usr/local/xmind/xmind" (className =? "XMind"))            
    , ((winMask,                    xK_F11      ), runOrRaise "./dbeaver/dbeaver" (className =? "DBeaver"))        
    , ((winMask,                    xK_F12      ), runOrRaise "VirtualBox" (className =? "VirtualBox"))    
    , ((winMask,                    xK_space    ), runOrRaisePrompt mySP)
    , ((winMask .|. shiftMask,      xK_space    ), shellPrompt mySP)
    , ((winMask .|. controlMask,    xK_space    ), windowPromptGoto mySP)
    , ((0,                          xK_Print    ), unsafeSpawn "gnome-screenshot")
    , ((altMask .|. controlMask,    xK_Right    ), moveTo Next (WSIs (return $ not . (=="NSP") . W.tag)))  
    , ((altMask .|. controlMask,    xK_Left     ), moveTo Prev (WSIs (return $ not . (=="NSP") . W.tag)))
    , ((winMask .|. shiftMask,      xK_Right    ), shiftTo Next (WSIs (return $ not . (=="NSP") . W.tag)))
    , ((winMask .|. shiftMask,      xK_Left     ), shiftTo Prev (WSIs (return $ not . (=="NSP") . W.tag)))
    , ((winMask .|. controlMask,    xK_Right    ), shiftTo Next EmptyWS)
    , ((winMask .|. controlMask,    xK_Left     ), shiftTo Prev EmptyWS)
    , ((winMask,                    xK_Tab      ), sendMessage NextLayout >> (dynamicLogString myPP >>= \d->safeSpawn "gnome-osd-client" [d]))
    , ((altMask,                    xK_Tab      ), windows W.focusDown)
    , ((altMask .|. shiftMask,      xK_Tab      ), windows W.focusUp)
    , ((controlMask,                xK_Down     ), windows W.swapDown)
    , ((controlMask,                xK_Up       ), windows W.swapUp)
    , ((winMask,                    xK_Left     ), sendMessage Shrink)
    , ((winMask,                    xK_Right    ), sendMessage Expand)
    , ((winMask,                    xK_Down     ), sendMessage MirrorShrink)
    , ((winMask,                    xK_Up       ), sendMessage MirrorExpand)
    , ((winMask,                    xK_minus    ), windows W.shiftMaster)
    , ((winMask,                    xK_comma    ), sendMessage (IncMasterN 1))
    , ((winMask,                    xK_period   ), sendMessage (IncMasterN (-1)))
    , ((winMask,                    xK_n        ), refresh)
    , ((winMask .|. shiftMask,      xK_n        ), setLayout $ XMonad.layoutHook conf)
    , ((winMask ,                   xK_a        ), sendMessage Taller)
    , ((winMask ,                   xK_z        ), sendMessage Wider)
    , ((winMask .|. controlMask,    xK_n        ), sendMessage Reset)
    , ((winMask,                    xK_m        ), sendMessage (Toggle "Full") >> (dynamicLogString myPP >>= \d->safeSpawn "gnome-osd-client" [d]))
    , ((winMask,                    xK_t        ), withFocused $ windows . W.sink)
    , ((winMask .|. shiftMask,      xK_t        ), sinkAll)    
    , ((winMask,                    xK_f        ), sendMessage ToggleStruts)
    , ((winMask,                    xK_w        ), kill)
    , ((altMask,                    xK_F4       ), kill)
    , ((winMask,                    xK_q        ), broadcastMessage ReleaseResources >> restart "xmonad" True)
    , ((winMask .|. shiftMask,      xK_q        ), spawn "gnome-session-quit")   
    ]

    ++
    -- mod-[1..9], Switch to workspace N
    -- mod-shift-[1..9], Move client to workspace N
    [ ((m .|. winMask, k), windows $ f i)
        | (i, k) <- zip (XMonad.workspaces conf) [xK_1 .. xK_9]
        , (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)] ]

-- mouse bindings 
myMouseBindings (XConfig {XMonad.modMask = modMask}) = M.fromList $
    [ ((winMask, button1), (\w -> focus w >> mouseMoveWindow w))
    , ((winMask, button2), (\w -> focus w >> windows W.shiftMaster))
    , ((winMask, button3), (\w -> focus w >> Flex.mouseResizeWindow w)) ]

-- decoration theme
myDeco = defaultTheme
    { activeColor           = "orange"
    , inactiveColor         = "#222222"
    , urgentColor           = "yellow"
    , activeBorderColor     = "orange"
    , inactiveBorderColor   = "#222222"
    , urgentBorderColor     = "yellow"
    , activeTextColor       = "orange"
    , inactiveTextColor     = "#222222"
    , urgentTextColor       = "yellow"
    , decoHeight            = 10 }

-- tab theme
myTab = defaultTheme
    { activeColor           = "black"
    , inactiveColor         = "black"
    , urgentColor           = "yellow"
    , activeBorderColor     = "orange"
    , inactiveBorderColor   = "#222222"
    , urgentBorderColor     = "black"
    , activeTextColor       = "orange"
    , inactiveTextColor     = "#222222"
    , urgentTextColor       = "yellow" }

-- shell prompt theme
mySP = defaultXPConfig
    { bgColor               = "black"
    , fgColor               = "white"
    , bgHLight              = "gray"
    , fgHLight              = "black"
    , borderColor           = "orange"
    , promptBorderWidth     = 2
    , position              = Bottom
    , height                = 40
    --, autoComplete        = Just 1000
    , historySize           = 1000 }

-- dynamicLog theme (suppress everything but layout)
myPP = defaultPP
    { ppLayout  = (\ x -> case x of
      "Hinted ResizableTall"        -> "[|]"
      "Mirror Hinted ResizableTall" -> "[-]"
      "Hinted Tabbed Simplest"      -> "[T]"
      "Mosaic"                      -> "[M]"
      "Full"                 -> "[ ]"
      _                      -> x )
    , ppCurrent             = const ""
    , ppVisible             = const ""
    , ppHidden              = const ""
    , ppHiddenNoWindows     = const ""
    , ppUrgent              = const ""
    , ppTitle               = const ""
    , ppWsSep               = ""
    , ppSep                 = "" }

-- layouts
myLayout = avoidStruts $ toggleLayouts (noBorders Full)
    (smartBorders (tiled ||| mosaic 2 [3,2] ||| Mirror tiled ||| layoutHints (tabbed shrinkText myTab)))
    where
        tiled   = layoutHints $ ResizableTall nmaster delta ratio []
        nmaster = 1
        delta   = 2/100
        ratio   = 1/2

-- special windows
myManageHook = composeAll
    [ className =? "MPlayer"                --> doFloat
    , className =? "Gimp-2.6"               --> doFloat
    , className =? "Gnome-panel"            --> doIgnore
    , className =? "XVkbd"                  --> doIgnore
    , className =? "Cellwriter"             --> doIgnore
    , className =? "Gtkdialog"              --> doFloat
    , resource  =? "desktop_window"         --> doIgnore
    , className  =? "Xmessage"              --> doCenterFloat
    , className =? "Unity-2d-panel"         --> doIgnore
    , isFullscreen                          --> doFullFloat
    , isDialog                              --> doCenterFloat
    , title =? "RSSOwl"                     --> doIgnore
    , title =? "Dbeaver"                    --> doIgnore
    , title =? "Xmind-bin"                  --> doIgnore
    , title =? "AptanaStudio3"              --> doIgnore
    , resource =? "sun-awt-X11-XDialogPeer" --> doCenterFloat
    , title =? "screenkey"                  --> doIgnore
    , className =? "Gloobus-preview"        --> doCenterFloat
    --                                      x y w h
    , scratchpadManageHook $ W.RationalRect 0 0 1 0.42
    , manageDocks ] <+> manageHook defaultConfig

-- let Gnome know about Xmonad actions
myLogHook = ewmhDesktopsLogHookCustom scratchpadFilterOutWorkspace >> updatePointer (Relative 0.5 0.5)

myConfig = ewmh defaultConfig
    { terminal           = "terminator"
    , borderWidth        = 2
    , normalBorderColor  = "black"
    , focusedBorderColor = "orange"
    , focusFollowsMouse  = True
    , modMask            = mod4Mask
    , keys               = myKeys
    , mouseBindings      = myMouseBindings
    , layoutHook         = myLayout
    , manageHook         = myManageHook
    , startupHook        = gnomeRegister
    }

-- need to override ewmh's logHook cause I'm using Scratchpad
main = xmonad $ myConfig
    { logHook            = myLogHook }

Productividad en el escritorio Linux: Tiling

2011-11-25T00:00:00+01:00

Los Gestores de Ventanas de Mosaico (Tiling Windows Manager) son el gran desconocido entre la mayoría de usuarios de Linux. Y sin embargo, a mi juicio, suponen el salto más importante en productividad en el escritorio linux que se haya producido en mucho tiempo. Permiten manejar todo el escritorio sin apenas despegar las manos del teclado y sin verse relegado a emplear únicamente la consola. Las ventanas se distribuyen ellas solas de forma automática por la pantalla y no es necesario emplear el ratón para moverlas y redimensionarlas (aunque puede seguir empleándose, naturalmente).

A diferencia de un gestor de ventanas tradicional, a los que estamos normalmente acostumbrados, las ventanas no se apilan y flotan unas encima de otras, si no que se redistribuyen por toda la pantalla de acorde a un esquema previo (variable) sin solaparse entre ellas, quedando todas a la vista de forma simultanea. De ahí el símil del mosaico, donde el mismo seria el escritorio y donde las ventanas serian las teselas que lo componen. Puede no ser fácil visualizar de entrada en que consiste exactamente esto y como funciona, luego los vídeos nos ayudarán a entender mejor de lo que estoy hablando. Aunque uno no aprecia realmente las ventajas que aportan hasta que prueba uno.

¿Que ventajas tienen?

Primero mencionar que esto no es una idea nueva, ni mucho menos, esto ya lo inventó en 1981 Xerox (el inventor a su vez de los entornos de ventanas) e incluso MS Windows 1.0 lo empleaba. La razón de que algo desarrollado desde hace dos décadas aún no haya llamado demasiado la atención hasta ahora, es bien sencilla, el triunfo de un dispositivo de entrada más amigable e intuitivo que el teclado: el ratón. La metáfora de el entorno de ventanas con el escritorio junto con la del ratón como la extensión de nuestro brazo, propiciaba que fuera lo más natural emplearlo para mover las ventanas y redimensionarlas. Pero que sea más fácil o intuitivo no quiere decir que sea más eficiente, nadie en su sano juicio escribiría un documento empleando el ratón sobre un teclado virtual ni realizaría retoque fotográfico empleando únicamente el teclado. ¿Pero cuantos dirían que el teclado es el medio más eficiente para manejar las ventanas?

En una pantalla de grandes dimensiones y elevada resolución (e.g. un monitor de 24" y 1920x1200) es muy frecuente andar redimensionando continuamente las ventanas para acomodarlas y redistribuirlas dentro del escritorio. Nos sobra espacio por todos los lados y la mayoría de las aplicaciones que en monitores y resoluciones menores empleábamos maximizadas, ahora son incomodas de usar a pantalla completa (e.g. navegador web). ¿No sería útil que las ventanas se recolocaran y redimensionaran automáticamente por si solas? Más o menos esto es lo que viene a hacer un gestor de ventanas de mosaico.

Pero cuales son las ventajas reales de este sistema:

Las ventanas se organizan solas, muchas veces no necesitas mover o redimensionar una ventana, simplemente aparece en un lugar adecuado y con las dimensiones adecuadas. Una vez le que coges el truco te organizas de manera que esto ocurre con cierta naturalidad.
Se aprovecha todo el espacio de la pantalla. Las ventanas se ajustan a todo el espacio libre disponible del escritorio. Aún así pueden emplearse paneles, docks, ...
Las ventanas normalmente apenas tienen marco y carecen de barra de titulo y decoraciones, por lo tanto se ahorra espacio. Combinado con un menú integrado como el Global Menu de Unity, se ahorra mucho espacio.
No es un método excluyente, aún se pueden emplear con toda normalidad las ventanas flotantes como habitualmente. Incluso pueden convivir entre ellas sin problema alguno.
En un sistema de múltiples monitores se facilita mucho el manejo de las múltiples ventanas y el tener simultáneamente abiertas un número elevado de ellas es algo realmente sencillo.
Es posible automatizar el tamaño, posición y escritorio virtual en donde se situara la ventana(s) de una aplicación al iniciarse, lo que abre un mundo de posibilidades.
Es posible tener múltiples escritorios virtuales (usualmente 9 por monitor) con características distintas en cada uno. Puede ser un esquema distinto (desde una simple rejilla a un escritorio normal) o un escritorio para cada tarea (e.g. 1 - navegar, 2 - correo y redes sociales, 3 - trabajo, 4 - terminales, ...)
Mover las ventanas, redimensionarlas, lanzar aplicaciones, cerrarlas, ... y manejar los escritorios virtuales desde el teclado es mucho más eficiente que emplear el ratón para lo mismo.
Te olvidas de buscar una ventana entre la pila de ventanas flotantes sobre el escritorio, es sencillo incluso encontrar una ventana dentro de otro escritorio virtual (con unos gestores más que otros). Los escritorios modernos permiten mostrar un mosaico con todas las aplicaciones abiertas (Exposé, Scale, ...), ¿pero que ocurre cuando tienes abiertas cerca de 30? con un twm la localizas enseguida si lo configuras adecuadamente, en mi caso menos de 2 segundos.
Te permite organizar las ventanas en función de múltiples patrones distintos: rejillas, columnas, filas, espirales, por pestañas, etc... de forma automática, acomodándose a múltiples situaciones distintas.
Se pueden emplear de forma autónoma, sin un escritorio detrás (gnome, kde, ...) lo que permite tener un sistema muy ligero ideal para equipos poco potentes.
Puede ser una manera de mejorar la accesibilidad del escritorio para aquellos que encuentren dificultades para manejar un ratón pero puedan defenderse con un teclado.

Inconvenientes

No son para todo el mundo. Soy plenamente consciente de ello, una buena mayoría de los usuarios son reticentes a aprenderse los atajos de teclado de una aplicación (hay quien no sabe cortar y pegar desde él), así que entiendo perfectamente que siquiera lleguen a plantearse el emplearlos. De hecho los tímidos avances que están realizando los escritorios en este sentido implican el uso del ratón para implantar un sucedáneo de este sistema. También es una cuestión de gustos, habrá a quien simplemente la desagradará el como funciona este sistema.

Por otro lado los profesionales multimedia que requieren un uso elevado del ratón probablemente prefieran seguir empleando un gestor de ventanas tradicional, aunque los gestores de mosaico pueden moverse con soltura en este entorno.

También es cierto que la mayoría de ellos requieren un esfuerzo por nuestra parte para configurarlos a nuestro gusto. Aunque es precisamente esto lo que nos permite configurarlos exactamente a nuestro gusto, con muchas posibilidades de configuración. Pero es una barrera de entrada importante para los gestores más potentes y completos. Alguno hasta requiere conocimientos en algún lenguaje de programación (C, Lua, Haskell)

Aunque por un lado pueden suponer una ventaja en la accesibilidad a determinados discapacitados, pueden suponer un escollo para otros, pues no están tan adaptados como puedan estarlo los escritorios tradicionales para determinadas discapacidades.

Tipos de gestores

Básicamente existen dos tipos de gestores de ventanas de mosaico, en función de el modo de organización de las ventanas.

Manuales, requieren que el usuario sea quien decida la posición (a veces el tamaño) de las ventanas, con el inconveniente de la perdida de tiempo a costa de lograr un control más preciso.
Automáticos, ajustan automáticamente la posición y el tamaño de las ventanas en función del esquema por defecto. Posteriormente podemos variar tanto el esquema como la posición y tamaño de las ventanas individuales.

Adaptación de la idea en los escritorios más comunes

Tal y como ocurre con los lanzadores de aplicaciones, los escritorios más tradiciones de linux comienzan a incorporar esta idea a sus desarrollos, en mayor o menor medida. Unity, Compiz, Gnome y KDE se han atrevido a dar un paso en esta dirección en sus últimas versiones:

Compiz Grid, es un plugin de Compiz que permite realizar un tiling primitivo, empleando el ratón o el teclado. Divide la pantalla en una rejilla de 3 x 3 y permite que las ventanas se ajusten al tamaño de una cuadricula o varias. Manejarlo desde el teclado es muy sencillo, simplemente pulsamos Ctrl + Alt + una tecla del teclado numérico del 1 al 9 según la cuadricula a la que la queramos ajustar la ventana. Para cambiar el tamaño de la ventana mantenemos pulsadas las teclas Ctrl + Alt y volvemos a pulsar la tecla numérica las veces que sea necesario hasta tener el tamaño que deseemos. Es decir, si pulsamos Ctrl+Alt+7 nos sitúa la ventana en la parte superior izquierda de la pantalla ocupando 1/9 de la misma.
Unity, emplea el plugin Grid de compiz anterior, pero modificado desde la versión 11.10 para que se comporte como ellos desean. En este vídeo se puede ver como se comporta este plugin manejándolo desde el teclado. Personalmente opino que mejor lo hubieran dejado como estaba.

Demostración del tiling básico del plugin de Compiz, Grid, en Ubuntu 11.10 con Unity

Gnome Shell, tiene un tiling muy básico parecido al que emplea Unity. Te permite maximizar una ventana o ajustarla a la mitad derecha/izquierda de la pantalla simplemente arrastrándola al borde correspondiente.
KDE a partir de la versión 4.4 tiene un tiling bastante conseguido, aunque no tan avanzado como los gestores dedicados. Desde luego es el escritorio que ha apostado más fuerte por este sistema y el que mejores resultados obtiene. Aunque no viene activarlo por defecto, es necesario activarlo a mano. De momento solo permite elegir entre dos esquemas predeterminados: columnas y espiral (fibonacci).

Aplicaciones que funcionan como un gestor

Para aquellos que no quieran instalar un gestor o no empleen uno de los entornos de escritorio anteriores, siempre existe la posibilidad de emplear alguna de estas aplicaciones que emulan el comportamiento básico de un gestor de ventanas de mosaico. Ambos son del tipo manual.

QuickTile, es un script en python que ofrece las mismas funcionalidades que el plugin Grid de Compiz.
x tile, es una aplicación instalable (viene en los repositorios de algunas distros) que ofrece más opciones que la anterior.

Gestores más populares

Hay muchos y para todos los gustos. Incluso los hay disponibles para otros SOs como Mac OS X o Windows (es muy famoso el WinSplit-Revolution para Windows, en el que se basa el plugin Grid, aunque los primeros gestores para linux son del 2000 y WinSplit aparece en el 2007). Me centrare aquí solo en los más populares.

awesome

Automático. Escrito en C y Lua, es configurable y extensible en Lua. Basado en dwm

Uno de los dos grandes, junto con Xmonad. Es quizá el que más opciones presenta hoy en día. Está basado en XCB en vez de Xlib, lo que le proporciona mayor agilidad. Aporta su propia barra de información, bandeja del sistema (systray) y lanzador de aplicaciones integrado. Tiene un soporte de ratón superior a la competencia. Pero su desarrollo no es aún solido, varía demasiado a lo largo de las distintas versiones y te obliga a reconfigurarlo cada vez que sale una nueva.

bluetile

Automático. Escrito en Haskell. Basado en Xmonad

Es uno de los más sencillos de utilizar y de los más sencillos de probar. Es el más adecuado para probar por primera vez para los que se inician en esto. Está pensado para emplear conjuntamente con Gnome y pensando para que los están acostumbrados al ratón lo usen indistintamente con el teclado. En el siguiente vídeo realizado por su autor, Jan Vornberger, se puede ver como funciona:

dwm

Automático. Escrito, configurable y extensible en C.

Uno de los más ligeros, rápidos y simples. Su configuración se hace modificando su código fuente en C y luego hay que recompilarlo y reiniciarlo. Esto lo limita a usuarios avanzados con conocimientos de programación. Su diseño minimalista sido la inspiración para los dos más grandes: Awesome y Xmonad.

Para lanzar las aplicaciones se desarrolló dmenu un lanzador basado en texto, que es muy empleado en otros gestores. Funciona al igual que los lanzadores gráficos como Gnome Do.

i3

Manual. Escrito en C y configurable con ficheros de texto. Basado en wmii

Muy sencillo y que presume de estar bien documentado. Fácil de usar y configurar. Es manual, lo que le permite crear esquemas muy flexibles y personalizados, pero que por otro lado le resta comodidad.

wmii

Manual. Escrito en C y configurable en bash, rc, ruby o python

Escrito por el mismo desarrollador que dwm. Digamos que es el gestor equivalente a dwm pero manual.

xmonad

Automático. Escrito, extensible y configurable en Haskell. Inspirado en dwm

Muy potente, estable y con muchas opciones. Es altamente personalizable, con muchas extensiones disponibles. Se integra muy bien con Gnome y KDE. Tiene un desarrollo muy activo y una gran comunidad de usuarios detrás. Es el que empleo desde hace meses y le he dedicado un articulo completo.

Todos estos gestores están incluidos en los repositorios de Ubuntu, Debian, Gentoo y Arch Linux, y la mayoría están disponibles también en otras distribuciones.

Como curiosidad, mencionar otros dos, que aunque no son muy populares, están desarrollados en Python: tritium y qtile

Productividad en el escritorio Linux: Introducción

2011-11-24T00:00:00+01:00

En el último lustro se ha producido una renovación en el escritorio Linux buscando innovar, mejorar su funcionamiento, equiparlo a las evoluciones de otros SOs (Mac OS X) y porque no, intentar acercar a más usuarios al mundo linux.

Quizá la primera innovación importante fue el gestor de ventanas Compiz en el 2006 que tuvo una elevada repercusión en su momento por lo novedoso y lo espectacular de sus efectos 3D empleando OpenGL. También ese mismo año hacia su aparición LXDE, un entorno de escritorio ligero y rápido que supone un paso adelante dentro de las opciones poco ávidas de recursos. Luego dos años más tarde, KDE decide renovarse por completo con un nuevo diseño y nueva tecnología, convirtiéndose en el escritorio más avanzado del momento. Y este año Gnome ha presentado también un gran cambio, no tan radical a nivel tecnologico como el de KDE, pero si presentando un cambio de paradigma con su Gnome Shell, aún algo inmaduro. Ubuntu se ha desmarcado de gnome creando su propia alternativa empleando su propio Shell, Unity, con un enfoque parecido.

Todos estos cambios han traído avances tanto en el diseño como en la espectacularidad del escritorio linux, no teniendo nada que envidiarle en diseño ni usabilidad a la referencia tradicional en este campo, Mac OS X. Bien, ahora tenemos unos entornos de escritorio elegantes, completos y amigables, y cada vez más orientados al usuario final. De hecho, se ha evolucionado tanto en este sentido, que hemos pasado del tópico de que Linux era solo para expertos frente a una linea de comandos, a la situación actual en la que probablemente sea el escritorio más amigable y con menor curva de aprendizaje (para aquel que se inicia y nunca haya tenido contacto previo con un ordenador).

¿Se ha mejorado la productividad?

¿Pero que ocurre con los profesionales? ¿En que ha mejorado para ellos? Y cuando hablo de profesionales me refiero a todos aquellos que pasan la mayor parte de su jornada delante de la pantalla de un ordenador. ¿Que han aportado todos estos cambios a la productividad de estos usuarios, a su trabajo diario? Personalmente opino que estos cambios no han aportado absolutamente nada, puede que incluso hayan supuesto un paso atrás en algunos casos. Personalmente, Unity me parece una broma de mal gusto, está bien que se piense en los usuarios domésticos (aquellos que principalmente hacen uso de internet y multimedia), pero por favor, el resto no merecemos ser tratados como idiotas. Y Gnome Shell, bueno, dentro de lo malo, tiene la excusa de ser aún un desarrollo muy temprano, y aparenta ser más prometedor.

Desde mi punto de vista, los dos grandes avances en productividad en el escritorio linux que se han producido en los últimos años, provienen de dos ideas que han tenido un éxito muy dispar, pero que tienen en común estar basados en proyectos muy pequeños lejos de la repercusión de los grandes entornos de escritorio. Estas dos ideas son los Lanzadores de aplicaciones y los Gestores de ventanas de mosaico

Lanzadores de aplicaciones.

Es una idea genial, lanzar aplicaciones a partir de su nombre, simple y rápido. Antes de nada, dejar claro que el ratón es enemigo de la productividad, cualquiera con la suficiente experiencia sabe que realizar acciones a través del teclado es más efectivo que realizar las mismas a través del ratón. Alguien que conozca los atajos de teclado de una aplicación realizara el mismo trabajo en menos tiempo que otro que deba emplear el ratón para todo. Y el uso del ratón es además el principal causante del Sindrome del túnel carpiano entre los informáticos, y los que lo hemos sufrido -en mayor o menor medida- sabemos que no es ninguna broma. De hecho aunque los docks son visualmente más atractivos y repletos de llamativos iconos, no son tan eficientes como los lanzadores cuando manejamos un buen número de distintas aplicaciones.

La idea del lanzador de aplicaciones proviene de la aplicación Quicksilver desarrollada en 2006 para el SO de Apple. Dos años después aparecería la primera aplicación similar para linux, Gnome Do. Estas aplicaciones han tenido un gran éxito y son de sobra conocidas, por lo que no voy a profundizar más en ellas, simplemente apuntar que gracias a los plugins realizan bastantes más tareas que lanzar aplicaciones. Actualmente para linux hay disponibles los siguientes lanzadores de aplicaciones:

Gnome Do, programado en Mono, es probablemente el mejor lanzador disponible hoy día. Es muy rápido y con gran cantidad de plugins.
Synapse, programado en Vala. Es una buena alternativa a Do, rapidísimo y muy ligero.
Launchy, es multiplataforma y está escrito en C++. Más popular en sistemas Windows que en Linux.
Katapult, es un lanzador pensado para KDE. Escrito en C++
Gnome Pie, a medio camino entre un lanzador y un dock. Más espectacular que eficaz, escrito en Vala.
Kupfer, la última incorporación notable. Escrito en Python. Es el que empleo actualmente. Completo, rápido, ligero y no requiere de un composition manager para funcionar correctamente.

Tal es el éxito que han tenido estas aplicaciones que tanto Gnome 3 como Unity lo incluyen como pilar básico en sus Shells (combinado con un dock) y KDE 4 integra una aplicación similar denominada KRunner.

Gestores de ventanas de mosaico.

Merecen un articulo aparte para hablar de ellos.

Fabric & Rsync para realizar Backups

2011-07-13T20:21:00+02:00

En el anterior articulo empleaba fabric y rsync para sincronizar un directorio local y uno remoto en ambas direcciones. Además le añadía las funcionalidades de logger y notify para proporcionar información sobre el proceso durante y después de su ejecución. Y comenzaba el articulo recordando a lftp-mirror, el script que había creado para realizar la sincronización a través de FTP. Pero lftp-mirror realiza algo más que la sincronización, pues también permite realizar el archivado del directorio local en ficheros comprimidos y lanzar varias tareas en una sola ejecución.

Ahora he añadido esta funcionalidad al fichero fabric creado anteriormente. Así empleando este fichero podemos realizar el Backup periódico de varios servidores en una sola operación y de forma completamente automática (basta con programar su ejecución). Se sincronizan los dos directorios y se crea un archivo comprimido del directorio local por cada día de la semana. De este modo siempre tenemos una copia del estado del directorio remoto de los últimos siete días. Y al final del proceso en nuestro correo, un email con el informe del resultado por cada una de las tareas ejecutadas.

En este fichero, rsync_fabric.py, disponemos de tres posibles tareas:

$ fab -l

     A Fabric file for sync two directories (remote ⇄ local) with rsync.

Available commands:

    backup  Sync from remote to local & archive the local directory.
    down    Sync from remote to local.
    up      Sync from local to remote.

Con la primera realizamos el backup (sincronización + archivado) y con las siguientes solo la sincronización desde o hacia el servidor. Una de las ventajas de fabric es que nos permite concatenar tareas fácilmente desde la línea de comandos, así podemos lanzar varias sincronizaciones de forma simultanea. Para poder realizar esto, creo una configuración de sincronización por defecto y después creo una función para cada una las tareas adicionales que simplemente redefinen los valores de estas variables globales. Por ejemplo:

# Variables globales de sincronización predefenidas
env.host_string = "username@example.com"
env.remote = "/my_directory"
env.local = "/home/my_user/backups/my_directory"

# Redefinimos estas variables para otra configuración de sincronización. Por 
# supuesto, pueden tratarse de servidores distintos.
def _databases():
    global env
    env.host_string = "username@example.com"
    env.remote = "/databases"
    env.local = "/home/my_user/backups/databases"

Veamos ejemplos de como podemos utilizar estas tareas:

# "Si queremos sincronizar el contenido local hacia el remoto, por ejemplo 
# para subir los ficheros al servidor por primera vez. Empleando los valores 
# por defecto. El modificador -w lo empleo para que no se detenga en los 
# errores, que de ocurrir, los veremos luego en el informe final."
$ fab -w up
[localhost] local: rsync -pthrvz --delete /home/my_user/backups/my_directory/ 
 username@example.com:my_directory

Done.
# "Pero también podemos especificar una tarea distinta a la por defecto de 
# este modo. Sincronizando desde el servidor a nuestro directorio local las 
# bases de datos."
$ fab -w down:databases
[localhost] local: rsync -pthrvz --delete username@example.com:databases/ 
/home/my_user/backups/databases

Done.
# "Y por supuesto, podemos realizar varias tareas a la vez."
$  fab -w down backup:databases
[localhost] local: rsync -pthrvz --delete username@example.com:my_directory/ 
/home/my_user/backups/my_directory
[localhost] local: rsync -pthrvz --delete username@example.com:databases/ 
/home/my_user/backups/databases

Done.

No empleo contraseña alguna, ni en el fichero ni en la línea de comandos, podría hacerse perfectamente, pero prefiero emplear una clave RSA pública autorizada para las sesiones SSH en el servidor. Es bastante más seguro y cómodo. En los ejemplos no se ve la salida de rsync, pues es capturada (así como los erores) para ser mostrada a posteriori en los informes.

Un ejemplo de informe sería el siguiente:

START TIME =====================================================================
                                                    miércoles 13/07/11, 19:48:55
================================================================================

SCRIPT =========================================================================
fab (ver. Unknown)
Fabric Rsync
http://code.joedicastro.com/python-recipes

Syncing username@example.com:databases to /home/my_user/backups/databases
================================================================================

RSYNC OUTPUT ___________________________________________________________________

receiving file list ... done

sent 20 bytes  received 825 bytes  153.64 bytes/sec
total size is 827.76M  speedup is 979595.42

ROTATE COMPRESSED COPIES _______________________________________________________

Created file:

/home/my_user/backups/databases_13jul2011_19:49_mié.tar.gz

Deleted old file:

databases_13jul2011_19:37_mié.tar.gz

DISK SPACE USED ================================================================
                                                                        1.60 GiB
================================================================================

END TIME =======================================================================
                                                    miércoles 13/07/11, 19:50:02
================================================================================

Que como podemos ver, ha tardado poco más de un minuto en sincronizar 827.56 Megabytes y el total de espacio ocupado por el directorio y los siete archivos comprimidos es de 1.60 Gibibytes (1,72 Gigabytes).

Ventajas

Las ventajas de sincronizarlo con rsync + ssh vs ftp, como ya comenté en el anterior articulo son enormes. Se ahorra muchísimo tiempo y ancho de banda, lo que ayuda a no saturar la red y no tener que planificar con tanto cuidado las ventanas de backup. Por ejemplo he realizado unas pruebas y para las mismas condiciones: mismo servidor, mismo directorio, mismo horario y condiciones de red; la sincronización remoto → local a través de FTP emplea entre 35 y 45 minutos y cuando lo hacemos a través de rsync emplea entre 2 y 4 minutos. Ahí es nada, estamos hablando de un proceso ~13 veces más rápido.

Código

El código del fichero fabric es el siguiente:

#!/usr/bin/env python
# -*- coding: utf8 -*-

import os
import glob
import tarfile
import time
from get_size import get_size as _get_size
from get_size import best_unit_size as _best_unit_size
from logger import Logger as _logger
from notify import notify as _notify
from fabric.api import env, local

LOG = _logger()

#===============================================================================
# RSYNC HOSTS
#===============================================================================

# Your default host. No need any more if only wants a host.
env.host_string = "username@host"
env.remote = "/your/remote/path"
env.local = "/your/local/path"

# If wants to use various hosts, then define the previous variables like this, 
# one function per host. 
def _host_1():
    """Host variables for host_1."""
    global env
    env.host_string = "username@host_1"
    env.remote = "/your/remote/path/in/host_1"
    env.local = "/your/local/path/for/host_1"

def _host_2():
    """Host variables for host_2."""
    global env
    env.host_string = "username@host_2"
    env.remote = "/your/remote/path/in/host_2"
    env.local = "/your/local/path/for/host_2"

# ...
#
# def _host_n():
#     """Host variables for host_n."""
#     global env
#     env.host_string = "username@host_n"
#     env.remote = "/your/remote/path/in/host_n"
#     env.local = "/your/local/path/for/host_n"

#===============================================================================
# END RSYNC HOSTS
#===============================================================================

def _log_start():
    """Create the Start time info block for the log."""
    # Init the log for multiple hosts. Do not repeat the previous logs.
    if LOG.get():
        LOG.__init__()
    LOG.time("Start time")

def _log_end(task):
    """Create the End time info block and send & write the log."""
    _notify("Rsync", "Ended" , "ok")
    LOG.time("End time")
    LOG.free(os.linesep * 2)
    LOG.write(True)
    LOG.send("Fabric Rsync ({0})".format(task))

def _check_local():
    """Create local directory if no exists."""
    if not os.path.exists(env.local):
        os.mkdir(env.local)

def _rsync(source, target, delete):
    """Process the _rsync command."""
    _log_start()
    LOG.header("Fabric Rsync\nhttp://code.joedicastro.com/python-recipes",
               "Syncing {0} to {1}".format(source, target))
    _notify("Rsync", "Start syncing {0} to {1}".format(source, target), "info")
    out = local("rsync -pthrvz {2} {0}/ {1}".
                format(source, target, "--delete" if delete == "yes" else ""),
                capture=True)
    _notify("Rsync", "Finished synchronization", "ok")
    LOG.list("Rsync Output", out)
    if out.failed:
        LOG.list("Rsync Errors", out.stderr)

def _compress(path):
    """Compress a local directory into a gz file.

    Creates a file for each weekday, an removes the old files if exists"""
    os.chdir(os.path.join(path, os.pardir))
    dir2gz = os.path.basename(path)
    old_gzs = glob.glob('{0}*{1}.tar.gz'.format(dir2gz, time.strftime('%a')))
    gz_name = "{0}_{1}.tar.gz".format(dir2gz, time.strftime('%d%b%Y_%H:%M_%a'))
    gz_file = tarfile.open(gz_name, "w:gz")
    gz_file.add(path, arcname=dir2gz)
    gz_file.close()
    output = os.linesep.join(['Created file:', '', os.path.join(os.getcwd(),
                                                                gz_name)])
    for old_gz in old_gzs:
        os.remove(old_gz)
        output += os.linesep.join([os.linesep, 'Deleted old file:', '', old_gz])
    return output

def _archive():
    """Archive the local directory in a gz file for each weekday."""
    _notify('Rsync', 'Compressing folder...', 'info')
    LOG.list('Rotate compressed copies', _compress(env.local))
    _notify("Rsync", "Finished compression", "ok")

def _get_diskspace():
    """Get the disk space used by the local directory and archives."""
    gz_size = sum([_get_size(gz) for gz in glob.glob('{0}*.gz'.
                                                     format(env.local))])
    log_size = _get_size(LOG.filename) if os.path.exists(LOG.filename) else 0
    local_size = _get_size(env.local)
    size = _best_unit_size(local_size + gz_size + log_size)
    LOG.block('Disk space used', '{0:>76.2f} {1}'.format(size['s'], size['u']))

def up(server=None, dlt='yes'):
    """Sync from local to remote."""
    globals()["_" + server]() if server else None
    _rsync(env.local, ":".join([env.host_string, env.remote]), dlt)
    _log_end(server)

def down(server=None, dlt='yes', archive=False):
    """Sync from remote to local."""
    globals()["_" + server]() if server else None
    _check_local()
    _rsync(":".join([env.host_string, env.remote]), env.local, dlt)
    if not archive:
        _log_end(server)

def backup(server=None):
    """Sync from remote to local & archive the local directory."""
    down(server, archive=True)
    _archive()
    _get_diskspace()
    _log_end(server)

El fichero siempre actualizado puede ser encontrado en mi repositorio

Sincronizar dos directorios con Fabric y Rsync

2011-07-06T22:02:00+02:00

Anteriormente habíamos visto como sincronizar un directorio remoto y uno local empleando solamente FTP. Ahora vamos a ver la forma de hacerlo empleando ssh y rsync. Para ello vamos a utilizar otra vez Python y una herramienta muy valiosa para cualquier sysadmin que se precie como es fabric (que descubrí gracias a Manuel Viera en esta pregunta en majibu). Evidentemente realizar la sincronización con rsync esta a años luz de hacerlo con FTP, la velocidad de sincronización, el tiempo empleado y la cantidad de datos a mover son mucho menores. FTP es algo que debería utilizarse únicamente cuando no disponemos de acceso via SSH.

La gran ventaja de fabric es que nos permite ahorrarnos el tener que implementar el acceso SSH con paramiko y la entrada de opciones y argumentos con argparse. Gracias a esto los scripts necesarios son mucho más cortos y limpios y su utilización es bastante más sencilla. Fabric ya incorpora una función para emplear rsync, rsync_project, dentro de su modulo de proyectos contribuidos fabric.contrib.project

Una forma de implementar esta sincronización en ambas direcciones empleando esta función predefinida sería esta:

from fabric.api import env, hosts, local
from fabric.contrib.project import rsync_project

env.host_string = "username@host"
REMOTE_PATH = "/your/remote/path"
LOCAL_PATH = "/your/local/path"

@hosts(env.host_string)
def rsync_up(dlt="yes"):
    rsync_project(REMOTE_PATH, LOCAL_PATH + "/", 
                  delete= True if dlt == "yes" else False)

def rsync_down(dlt="yes"):
    local("rsync -pthrvz {0}:{1}/ {2} {3}".
          format(env.host_string, REMOTE_PATH, LOCAL_PATH, 
          "--delete" if dlt == "yes" else ""))

Y luego solo tendríamos que llamar a la función deseada:

# "Para sincronizar de remoto a local"
$ fab rsync_down

El problema con la función rsync predefinida de fabric es que esta pensada únicamente para subir archivos a un servidor remoto, es decir, es una sincronización en una sola dirección, por eso implemento la sincronización en sentido contrario sin emplearla y empleando local. La autentificación de la sesión SSH puede realizarse especificando la contraseña dentro del propio fichero, pero va en contra del sentido común emplear un método tan inseguro como este. Lo lógico es emplear autorizaciones de sesiones SSH sin contraseña por medio de una clave pública.

Podríamos prescindir de la librería incorporada dentro de fabric y tendríamos algo como esto:

from fabric.api import env, local

env.host_string = "username@host"
REMOTE_PATH = "/your/remote/path"
LOCAL_PATH = "/your/local/path"

def _rsync(source, target, delete):
    """Process the _rsync command."""
    output = local("rsync -pthrvz {0}/ {1} {2}".
                   format(source, target, "--delete" if delete == "yes" else ""))

def up(dlt='yes'):
    """Sync from local to remote."""
    _rsync(LOCAL_PATH, ":".join([env.host_string, REMOTE_PATH]), dlt)

def down(dlt='yes'):
    """Sync from remote to local."""
    _rsync(":".join([env.host_string, REMOTE_PATH]), LOCAL_PATH, dlt)

Pero... un momento, si estamos empleado un comando local, no empleamos rsync_project y empleamos una clave pública para el acceso SSH, entonces no estamos empleando paramiko, ¿de que nos sirve emplear fabric?. Bueno, en realidad rsync_project también emplea local, por lo que no emplea paramiko. Pero las ventajas vienen de que, por ejemplo, este mismo script se podría modificar fácilmente para ejecutar rsync en el servidor en vez de en nuestra maquina local, empleando run en vez de local. Además podemos emplear el mismo fichero para añadir varias tareas más a realizar en el servidor, aparte de la sincronización. Podríamos prescindir de fabric y hacer esto mismo con un script con un número similar de líneas, pero esto nos permite centralizar todas las tareas más comunes sobre ese servidor en un único fichero. Por ejemplo podríamos añadir una tarea para hacer un respaldo previo de una base de datos en el servidor, empleando un comando remoto en el servidor, luego hacer la sincronización separada de la BDD y el resto de ficheros y finalmente eliminar ese respaldo. Puede haber cientos de razones para preferir emplear fabric antes de un script independiente para la sincronización.

Ejecución desatendida de la sincronización

Si queremos programar esta tarea, no sería mala idea que nos avisara de cuando comienza a ejecutarse y del resultado de la misma. Para ello puedo emplear Logger y notify, para implementar esta funcionalidad.

from logger import Logger as _logger
from notify import notify as _notify
from fabric.api import env, local

env.host_string = "username@host"
REMOTE_PATH = "/your/remote/path"
LOCAL_PATH = "/your/local/path"

def _rsync(source, target, delete):
    """Process the _rsync command."""
    log = _logger()
    log.header("Fabric Rsync\nhttp://code.joedicastro.com/python-recipes",
               "Syncing {0} to {1}".format(source, target))
    log.time("Start time")
    _notify("Rsync", "Start syncing {0} to {1}".format(source, target), "info")
    output = local("rsync -pthrvz {0}/ {1} {2}".
                   format(source, target, "--delete" if delete == "yes" else ""),
                   capture=True)
    _notify("Rsync", "Finished", "ok")
    log.list("Output", output)
    if output.failed:
        log.list("Error", output.stderr)
    log.time("End time")
    log.send("Fabric Rsync")

def up(dlt='yes'):
    """Sync from local to remote."""
    _rsync(LOCAL_PATH, ":".join([env.host_string, REMOTE_PATH]), dlt)

def down(dlt='yes'):
    """Sync from remote to local."""
    _rsync(":".join([env.host_string, REMOTE_PATH]), LOCAL_PATH, dlt)

De esta forma, nos avisaría con una notificación en el escritorio de su inicio y fin, y al acabarse la sincronización, tendríamos un informe en nuestro correo parecido a este:

SCRIPT =========================================================================
fab (ver. Unknown)
Fabric Rsync

Syncing username@host:/your/remote/path to /your/local/path
================================================================================

START TIME =====================================================================
                                                   miércoles 06/07/11, 21:50:48
================================================================================

OUTPUT _________________________________________________________________________

receiving file list ... done
./
index.php

sent 48 bytes  received 200 bytes  45.09 bytes/sec
total size is 99  speedup is 0.40

END TIME =======================================================================
                                                   miércoles 06/07/11, 21:50:54
================================================================================

Este fichero está disponible en mi repositorio.

Pelican - Repositorio

2011-07-05T23:02:00+02:00

Como complemento a la serie de artículos que he publicado sobre Pelican, el software que genera este blog, añado el repositorio, como había prometido, del contenido del mismo. El repositorio emplea el sistema de control de versiones Mercurial y está alojado en Bitbucket.

Las ventajas de disponer del contenido del blog en un repositorio son las de poder enmendar un error con suma facilidad y en muy poco tiempo, además de la de poder trabajar con distintas versiones del mismo (pruebas y producción). Además el repositorio en Bitbucket me proporciona una copia de seguridad adicional del sitio sin esfuerzo alguno. Y si alguien está interesado en crear su propio blog con Pelican y quiere saber como he realizado el mio, ahí tiene las claves. Salvo el propio Pelican (que no tendría mucho sentido) todo el material empleado para generarlo está en el. Y disponiendo del fichero fabric, se pueden descargar Pelican e instalar el entorno virtual en un minuto.

Para automatizar todas las tareas, incluso las más comunes del repositorio, he añadido al fichero fabric fabfile.py dos tareas más:

def commit(message):
    """Make a commit to the local mercurial repository."""
    local("hg add")
    local("hg commit -m '{0}'".format(message))

def push():
    """Make a push to the remote mercurial repository."""
    local("hg push ssh://hg@bitbucket.org/joedicastro/joedicastro.com")

Con estas puedo hacer un commit y un push a Bitbucket en un solo paso, por ejemplo:

fab commit:"Añadido articulo: Pelican - Repositorio" push

También he cambiado la página que generaba los archivos del blog, ya que no me gustaba el formato anterior: una fecha, un articulo. He pasado de esto:

{% extends "base.html" %}
{% block content %}
<section id="content" class="body">
<h1>Archivos de {{ SITENAME }}</h1>

<dl>
{% for article in dates %}
    <dt>{{ article.locale_date }}</dt>
    <dd><a href='{{ article.url }}'>{{ article.title }}</a></dd>
{% endfor %}
</dl>
</section>
{% endblock %}

a esto:

{% extends "base.html" %}
{% block content %}
<section id="content" class="body">
<h1>Archivos de {{ SITENAME }}</h1>
{%- set years_month = {} -%}
{%- set months = {1:'Enero', 2:'Febrero', 3:'Marzo', 4:'Abril', 5:'Mayo', 
                  6:'Junio', 7:'Julio', 8:'Agosto', 9:'Septiembre', 
                  10:'Octubre', 11:'Noviembre', 12:'Diciembre'} -%} 
{%- for article in dates -%}
  {%- if article.date.year not in years_month -%}
    {%- do years_month.update({article.date.year:[article.date.month]}) -%}
  {%- else -%}
    {%- if article.date.month not in years_month[article.date.year] -%} 
      {%- do years_month[article.date.year].append(article.date.month) -%}
    {%- endif -%}
  {%- endif -%}
{%- endfor %}

{% for year in years_month|sort(reverse=True) -%}
  <h2 class="year">{{ year }}</h2><dl>  
  {% for month in years_month[year] -%}
    <dt class="month">{{ months[month] }}</dt>
    {% for article in dates -%}
      {% if article.date.year == year and article.date.month == month -%}
        <dd><span class="day">{{ article.locale_date.split()[1] }}</span>  <a href='{{ article.url }}'>{{ article.title }}</a></dd>
      {%- endif %}
    {%- endfor %}
  {% endfor %}</dl>
{% endfor %}
</section>
{% endblock %}

Donde los artículos están archivados por año, mes y día, con un formato que personalmente me agrada bastante más.

El repositorio de este blog se encuentra en https://bitbucket.org/joedicastro/joedicastro.com/

Pelican - Configuración y personalización

2011-06-30T01:21:00+02:00

Con este articulo cierro la serie que le he dedicado a Pelican como herramienta idónea para crear blogs estáticos con mantenimiento cero. Aquí voy a tratar de la parte más compleja de Pelican, la que nos permite personalizarlo y adaptarlo a nuestros gustos y necesidades. El primer nivel de personalización se obtiene a través del fichero de configuración (aunque no es necesario, es recomendable emplearlo). El segundo nivel vendría mediante la personalización del tema empleado, bien creando uno nuevo o bien modificando el que viene por defecto. El último nivel vendría de modificar el propio Pelican. Todos son posibles y están a nuestro alcance, gracias a que es Software Libre.

Si bien yo he personalizado mi sitio con respecto al sitio por defecto, y aún quedan ciertas cosas que aún quiero cambiar, no he necesitado de momento más que modificar el fichero de configuración y el tema que viene por defecto. En Pelican no he tocado nada exceptuando el activar por defecto Markdown Extra, algo que Alexis tuvo como gentileza aceptar como modificación a Pelican. Es posible que en el futuro algunas de las cosas que tengo en mente me lleven a modificarlo, y espero poder así contribuir en alguna medida a su desarrollo.

Configuración

La configuración se hace a través de un fichero python, que en el ejemplo por defecto se llama pelican.conf.py y en nuestro ejemplo estaría en myblog.com/site/pelican.conf.py. Para llamar al fichero de configuración se utiliza la opción -s y en nuestro ejemplo sería:

$ pelican -s ./site/pelican.conf.py

Este es un tema que está muy bien resuelto en la documentación. De todos modos voy a hablar de unos cuantos campos interesantes y alguno no incluido dentro de la documentación. Entre paréntesis indico los valores por defecto.

OUTPUT_PATH ('output/') y PATH (None)

Empleando estos dos valores, conseguimos que solo tengamos que especificar el fichero de configuración en la linea de comandos empleada para llamar a Pelican. El primero define el directorio de salida donde queremos que se genere nuestro sitio y el segundo el directorio origen de nuestro contenido.
SITESUBTITLE (u'')

Un subtitulo que se puede poner al blog, e.g. un lema. No aparece documentado.
JINJA_EXTENSIONS ([])

Puede ser necesario habilitar ciertas extensiones de Jinja2 para personalizar el tema que vamos a emplear. Por ejemplo, para mostrar la nube de etiquetas con las etiquetas ordenadas alfabéticamente, he habilitado una extensión que necesitaba para el proceso de esta manera:
```
JINJA_EXTENSIONS = ['jinja2.ext.do']
```
STATIC_PATHS (['images',])

Te permite especificar los contenidos estáticos que quieres añadir a tu blog y que acabaran colgando de la carpeta static. Yo por ejemplo lo empleo para alojar las imágenes en static/pictures y el mapa flash que utilizo en el articulo Combatir el spam en Drupal en static/ammap así:
```
STATIC_PATHS = ["pictures", "ammap", ]
```
TAG_FEED (None) y TAG_FEED_RSS (None)

Te permiten establecer fuentes Atom y RSS por etiqueta, que es una opción muy interesante para quienes solo les interesa un tema de los que trates o para formar parte de un Planet sin mezclar temas. Eso si, lo lógico es modificar luego el tema para que aparezcan disponibles.
DIRECT_TEMPLATES (('index', 'tags', 'categories', 'archives'))

Estas son las plantillas del tema que generan una página por si mismas. No viene documentada, pero yo he cambiado los valores por defecto para añadir una página personalizada a la que redirijo los errores 404 (Página no encontrada) de esta manera:
```
DIRECT_TEMPLATES = ('index', 'tags', 'categories', 'archives', 'notfound')
```
PIWIK_URL y PIWIK_SITE_ID

Te permiten configurar tu sitio para emplear el magnifico sistema de analíticas web Piwik. Yo hace unos dos años que lo empleo en mis sitios, porque tiene la ventaja de que no dependes de un script de un dominio externo. Esto te ahorra consultas DNS y que la página se quede esperando a cargar completamente cuando estos fallan. De esta manera tienes el control total sobre las estadísticas de tu web sin tener que renunciar a la calidad de otros servicios externos.
FILES_TO_COPY (())

Básica si queremos emplear ficheros como .htaccess o robots.txt. No está documentada tampoco. El uso de la misma consiste en una tupla de tuplas con los valores de las rutas del fichero origen y su destino. En este sitio por ejemplo:
```
FILES_TO_COPY = (('extra/robots.txt', 'robots.txt'),
                 ('extra/favicon.ico', 'favicon.ico'),
                 ('extra/.htaccess', '.htaccess'),)
```

Personalización

Pero si realmente queremos personalizar el sitio, tanto en funcionalidad básica como en su aspecto, nos toca modificar el tema por defecto. Aquí podemos optar por tres vías: Crear el nuestro propio, empezar un tema casi desde cero, eligiendo el tema por defecto simple (solo texto) o partir de la base del tema por defecto notmyidea. Este último es el que hemos estado empleado en nuestro ejemplo y el que yo modifiqué hasta llegar donde lo tengo ahora.

Para comprender de que consta un tema y como podemos personalizarlo, lo mejor es analizar el tema notmyidea.

notmyidea/
├── static
│   ├── css
│   │   ├── main.css
│   │   ├── pygment.css
│   │   ├── reset.css
│   │   └── wide.css
│   └── images
│       └── icons
│           ├── delicious.png
│           ├── lastfm.png
│           ├── linkedin.png
│           ├── rss.png
│           └── twitter.png
└── templates
    ├── analytics.html
    ├── archives.html
    ├── article.html
    ├── article_infos.html
    ├── base.html
    ├── categories.html
    ├── category.html
    ├── comments.html
    ├── disqus_script.html
    ├── github.html
    ├── index.html
    ├── page.html
    ├── pagination.html
    ├── piwik.html
    ├── skribit_tab_script.html
    ├── skribit_widget_script.html
    ├── tag.html
    ├── taglist.html
    ├── tags.html
    ├── translations.html
    └── twitter.html

static/css

Aquí es donde se guardan las Hojas de estilo en cascada (CSS) que emplea el tema. Aunque la el fichero wide.css no es empleado por el tema, solo para la versión wide del mismo. Yo la eliminé como primera medida. Luego tenemos main.css que es la hoja de estilo principal, pygment.css que es la que emplea Pygments para el resaltado de sintaxis y reset.css para resetear los navegadores a unos valores comunes por defecto.

Si lo que queremos es tener un sitio con un buen rendimiento, deberíamos dar como mínimo dos pasos, consolidar todas la hojas de estilo en una sola y minimizar el tamaño de esta. Consolidarla en este caso es realmente sencillo, simplemente debemos insertar el contenido de reset.css al principio del fichero main.css y pygment.css al final del mismo. Depués hay que eliminar los imports de estas hojas en main.css*. Luego para minimizar su tamaño eliminar comentarios y lineas en blanco y poner una regla por línea.

Otro paso que dí para mejorar el rendimiento es no usar las web fonts externas (ni internas), que aunque le dan un aspecto inmejorable, hay que reconocerlo, requieren cargar otro recurso externo, desde mi punto de vista innecesario.

Lo mejor en estos casos es seguir siempre las recomendaciones de estas dos magnificas herramientas: YSlow de Yahoo y Page Speed de Google. Afortunadamente hay sitios web como GTmetrix o WebPagetest que nos permiten ver los resultados de ambas herramientas en nuestro sitio web sin necesidad de instalarlas (aunque para el desarrollo es más que recomendable). Si por ejemplo emplearamos GTmetrix los valores que arroja un sitio con el tema por defecto son:

Page Speed (tema por defecto) YSlow (tema por defecto)

B (80%) B (85%)

Valores bastante mejorables. Los valores actuales para este sitio, una vez personalizado el tema y configurado correctamente el .htaccess son:

Page Speed (tema personalizado) YSlow (tema personalizado)

A (91%) A (95%)

Y si nos fijamos en los resultados, las penalizaciones de rendimiento vienen de los scrips externos de Piwik y Disqus, principalmente de este último. Sin emplear estos scripts los valores suben a:

Page Speed (sin scripts) YSlow (sin scripts)

A (100%) A (98%)

En resumen, una optimización más que correcta, solo hay que ver los valores de las páginas del Top 1000 que ofrecen en GTmetrix. Obtener una optimización como esta con un CMS no es imposible (había conseguido unos valores solo un poquito peores con Drupal) pero si bastante más complicado. La experiencia del usuario depende mucho de estos valores, hay que contar con que no todo el mundo dispone de buenos accesos a Internet.

Evidentemente, después cada uno retocara el fichero CSS resultante a su gusto para personalizar el aspecto del sitio. En este caso estoy empleando CSS 3 y valida correctamente.

Page Speed (tema por defecto)	YSlow (tema por defecto)
B (80%)	B (85%)

Page Speed (tema personalizado)	YSlow (tema personalizado)
A (91%)	A (95%)

Page Speed (sin scripts)	YSlow (sin scripts)
A (100%)	A (98%)

static/images/icons

Son los iconos empleados por la hoja de estilo para los enlaces sociales de la parte inferior de la página. Yo no los empleo. ¿Entonces como se ven? Bueno lo primero que hice fue crear un sprite para cargar una sola imagen en lugar de 6, es decir menos solicitudes al servidor. Después incorporé esta imagen dentro del propio fichero CSS con un Data URL, y gracias a haberla optimizado hasta ocupar solamente ~3k, me compensaba hacerlo. Una consulta menos al servidor. Lo mismo hice después con el logotipo (1K) y al final no se carga ninguna imagen por defecto en el blog, 0 consultas. Los navegadores modernos soportan esto sin problemas, los que no lo hacen, no muestran la imagen, solo el enlace, que tampoco es un ningún problema.

Así es como queda en main.css la imagen que da vida a los iconos de los enlaces a la redes sociales:

#extras div[class='social'] a{background-repeat:no-repeat;background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAACSCAMAAAB7VbqAAAAAwFBMVEWQBQCWFxU5VpedVy+tUE5LZaBPZZZDabDdYSpke75vfZBkfbJZgc+heztshKvldjBgld91j9+Uj4p5ksZ/lLzthzLqhz+MmrAcvuaDofihpYRzq/D4mDeUp9KetkSirsnQpKWpvV/qqHvHsJjnqY/3qWK1ubbIun2jwLHEu7xm1O+6xoOtv++7wte0yNzxwH563e/3xJjK06ya5vXY3p7U2+3e3tbm6IT63cLn7czr7fbZ9Prz7+r8+O/3+fb9//z6WVfkAAADNElEQVRIx9WV4XqiPBCFoyu4aVjQBrW2ImBX3aJYdQERIbn/u9qTRKzd7/n+b88jxHlnMswEY4hIGYUcLZYKklLbtixqNBymhNl2yG/2lBFqu1LKKjD2dEioxfIKKOfaVgA+HkoptsoGoDxPA8orKZTtEIdyNWE4zXEbUgVokAq4p1JuqQHIX8G9lYK2EdOpkNuhlJxec+TTrcxpJVENAOK3iK9oLkOLEmbqGQZ4dMAtRlJj617QZErQvqpHiVLVvvhL/y6oFx40HhktaqJt9X2mtSDwHg7L1p6NAJZY9eZwB8aHsgF61zaAnr8spXxX9piMR8umxAQQZBp5ZDTSOZYgzXjkKTCbvTeKNPLgKaCTK/dCNldQlu9wL0aNHH9XADnK2UGWXil/GoDJyFx6P69gNlPPWy698cIDWOj68DzvO+Qt0D7MsXcV2v86by55+qSEPP3+pKf/ARfxF5Dy8gH2+/0N7Pc3oCUMSJIWyESBRANxgX4nyQ1cEiMDEkR8BheT4jYl2bdJW5DsdczlA9z09N/2v86bw1Vs4vl8c6xbcI7ncQxkCBFFPM8a0QAfDTjOM70453lc630bx2ezXJt5oUARx40BmQF3EfFroXJs5gaU30inF+G3vombBnuu7JFer9OJ1JQMZcQ/SK8WEekRVRYqjb+RSMq60yHF8VzXRVHAWUsV0TZVIEekctzafEPKTnS/o+qog7z361FHkfhK/5ZV0MrnPAgqEvBWYZoGPCSt6aujLGScuC5j+LAdNkAVALCrUuVndwARvhoJs3C3WSXUFB8HjtW1LFxCvz3WtQC03Bw5fOsDdEPl794BPMW9Ap3DAMuyCc5nJQ2sO2AB+BgYCU1dCkwwhjjnfNUO8ycTl/lf6pxTtzzfQXl1BduXAQ5/7jiDl50CgcMnq6Ku69WEOQHAgD8+Pq5WbysMLle78tdq8jDR4oMc4HzKsuPuBRoMLKHB6+spG2hgrwCydQZpQH0NTmsgB/4BTVe1AphyNCBXoMk2p9MvB7bT1xEitB+eFXCch3WhSl/Z/T6dcMddr581KAD6fdd9fnyoTbdvrN93+v2uXbTt17sQyvV6/AE7UZJYs2UOngAAAABJRU5ErkJggg==");padding-left:25px;}
.social a[href*='atom.xml']{background-position:3px 6px;}
.social a[href*='rss.xml']{background-position:3px -20px;}
.social a[href*='twitter.com']{background-position:3px -46px;}
.social a[href*='identi.ca']{background-position:3px -72px;}
.social a[href*='facebook.com']{background-position:3px -98px;}
.social a[href*='bitbucket.org']{background-position:3px -124px;}

static/templates

Estas son las plantillas que dan vida al tema y emplean Jinja2. Los nombres son bastante descriptivos de la función que realiza cada una de ellas. En mi caso hay una serie de ellas que no empleo, como son: analytics.html, article_infos.html, github.html, skribit_tab_script.html, skribit_widget_script.html, translations.html y twitter.html. He realizado bastantes modificaciones en las plantillas y me extendería demasiado explicándolo, además sigo realizando cambios. Aún no lo tengo todo como yo lo quiero, y aún voy a personalizar y optimizar más cosas. Cuando lo tenga todo listo, pienso publicar un repositorio con el contenido que genera este blog, tanto a efectos de copia de seguridad, como de que le pueda servir a alguien como guía para montar el suyo propio.

De todos modos si puedo decir que he añadido una que no existía, notfound.html para los errores 404 y pienso crear una nueva para los errores 403. Además he creado los enlaces para los feeds RSS y Atom de las etiquetas y eliminado el bloque de información que aparecía en cada articulo. Además en la plantilla tags.html que por defecto viene vacía, he creado lo necesario para generar la nube de etiquetas. tags.html queda entonces así:
```
{% extends "base.html" %}
{% block content %}
<section id="content" class="body">
<h1>etiquetas</h1>
  <ul id="cloud">
    {%- set all_tags = {} -%}
    {% for ctag in tag_cloud -%}
      {% do all_tags.update({ctag.0:ctag.1}) %}
    {%- endfor %}
    {% for tag in all_tags|sort %}
      <li class="tag-{{ all_tags[tag] }}"><a href="tag/{{ tag|replace(" ", "%20") }}.html">{{ tag }}</a></li>
    {% endfor %}
  </ul>
</section>
{% endblock %}
```
También he realizado las modificaciones pertinentes para que el contenido validara perfectamente en HTML 5.

Pero como ya he dicho es un proceso que aún no he finalizado. Cuando lo termine y publique el repositorio, actualizaré también este articulo.

Pelican - Publicación y automatización

2011-06-28T23:54:00+02:00

Una vez que sabemos como instalar Pelican y crear contenido con él, es hora de saber como convertir ese contenido en un blog real disponible en internet. Es decir, saber como publicar ese contenido. Como hemos visto hasta ahora, al constar básicamente de simples ficheros HTML, un servidor de archivos es más que suficiente para servir el blog. Esto nos abre un gran abanico de posibilidades, desde emplear un potente (y barato) servidor de ficheros en la nube como Amazon S3 (un ejemplo), pasando por las páginas web estáticas que nos permiten repositorios como Bitbucket o GitHub (un ejemplo), por los tradiciones hostings compartidos (e.g. este blog), hasta un servidor casero sencillo montado sobre un NAS.

Aún cuando es posible emplear un simple servidor de archivos para alojar el blog, siempre es mejor contar con un servidor web detrás (Apache, nginx, lighttpd, ...) que nos permita hacer redirecciones para nuestras antiguas páginas si ya disponíamos de un blog anterior o manejar los errores HTTP 404 o 403 de forma personalizada.

Publicar el contenido

Publicar el contenido de una web es tan sencillo como volcar el contenido del directorio que nos genera Pelican (en nuestro ejemplo sería myblog.com/site/output/*) en el directorio destino de nuestro servidor web. Dependiendo del método que hayamos elegido para alojar nuestro blog, puede ser tan sencillo como una copia de archivos o emplear FTP (SFTP) ó SSH (SCP, Unison ó rsync). Aquí el tema radica no en la primera vez que vayamos a subir el contenido al servidor, si no en las sucesivas, a medida que vayamos creando contenido nuevo. No tendría ningún sentido volver a subir todo el contenido cada vez, si no solamente el nuevo o el que haya cambiado. Para eso necesitamos sincronizar los dos directorios.

Si solamente disponemos de acceso FTP (o SFTP) a nuestro servidor, entonces tendremos que emplear una herramienta que nos permita la sincronización sobre FTP, como puede ser lftp. Y el proceso se puede automatizar con un script como el que describo en Sincronizar una carpeta local y una remota a través de FTP: lftp-mirror. Si disponemos de acceso a través de SSH, entonces la elección es clarisima, rsync. Más adelante explico una manera de emplearlo de forma automática.

Cualquiera de ambas soluciones nos permite subir el contenido en apenas segundos, (sobre todo en el caso de rsync) cuando se trata de añadir un articulo nuevo, por ejemplo. Y lo mismo a la hora de hacer una rectificación, es tan inmediato como lo pueden ser plataformas como Wordpress, Drupal y similares. Además, con las potentes herramientas que existen para hacer cambios múltiples en varios ficheros de texto a la vez, se pueden realizar tareas casi imposibles con una plataforma de blogs tradicional sin recurrir a consultas SQL en la BDD o a plugins externos. Una de estas herramientas, sin recurrir a find, grep, awk y sed, puede ser regexxer.

Generar el contenido en el propio servidor

Si el alojamiento que hemos escogido nos permite instalar programas python, entonces tenemos la posibilidad de instalar Pelican en el servidor remoto. De esta formar podríamos subir únicamente los archivos markdown o reStructuredText al servidor y generar allí mismo el contenido web. De este modo la cantidad de datos a subir sería ridícula y un simple comando FTP nos serviría. Luego bien podríamos lanzar Pelican a través de una consola SSH o bien dependiendo del servidor, tener un demonio corriendo que cuando detectara un cambio en el sistema de ficheros lanzará un script que generara el contenido con Pelican.

Otra posibilidad que me convence más, es de la poder instalar un repositorio en el servidor con un software de control de versiones, como Git o Mercurial. La idea sería tener un repositorio local, y al hacer un push hacia el repositorio remoto, a través de un hook activar la generación de la página con Pelican. Esto nos permitiría además poder tener varias copias del repositorio (por ejemplo en GitHub o Bitbucket) y por lo tanto de la web, haciendo "innecesarias" las copias de seguridad.

Automatizar todos los procesos

Pero lo ideal es poder automatizar todas las tareas que hemos visto hasta ahora, empleando unos pocos comandos para realizarlas sin esfuerzo alguno (bueno, a menos que tengas tú ghostwriter particular, me temo que los artículos los seguirás teniendo que escribir tú). Para poder realizar esto disponemos de la fantástica y potente herramienta Fabric (el Capistrano para Python) que nos permite ejecutar comandos locales o remotos en múltiples servidores. Esto nos permite hacer despliegues de software sin apenas esfuerzo en distintas máquinas, copiar ficheros o ejecutar tareas repetitivas empleado una corta serie de comandos. Una grandísima herramienta para administradores de sistema y desarrolladores.

Lo único que necesitamos es instalar fabric y crear un fichero llamado fabfile.py donde especificaremos las tareas que queremos programar. Para instalar la última versión estable de fabric, lo mejor es emplear easy_install o pip

$ pip install fabric

Una vez creado el fichero fabfile.py, lo único que tendremos que hacer para ejecutar una tarea del mismo, sería escribir el comando fab seguido del nombre que le hayamos dado a la tarea (este sería el funcionamiento básico). Y la tarea se ejecutaría inmediatamente.

Para comprender mejor como funciona Fabric, muestro aquí el contenido actual de mi fichero fabfile.py

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    fabfile.py: A fabric script for generate my personal blog
"""

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "28/06/2011"
__version__ = "0.2"

import os
from fabric.api import *
from fabric.contrib.project import rsync_project
from fabric.contrib.console import confirm

PELICAN_REPOSITORY = "git://github.com/ametaireau/pelican.git"
PROD = "joedicastro.com"
PROD_PATH = "/home/joedicastro/webapps/joedicastro"
LOCAL_WEB = os.path.join("~/www", PROD)
ROOT_PATH = os.path.abspath(os.path.dirname(__file__))
ENV_PATH = os.path.join(ROOT_PATH, "env")
PELICAN = os.path.join(ROOT_PATH, "pelican")
CONFIG_FILE = os.path.join(ROOT_PATH, "site/pelican.conf.py")
OUTPUT = os.path.join(ROOT_PATH, "site/output")

def _valid_HTML():
    """Remove the obsolete rel="" and rev="" links in footnotes."""
    for path, dirs, files in os.walk(OUTPUT):
        for fil in files:
            if fil[-5:] == ".html":
                local("sed -i {0} -r -e 's/re[l|v]=\"footnote\"//g' {0}".
                      format(os.path.join(path, fil.replace(" ", r"\ "))))

def _make_env():
    """Make a virtual enviroment"""
    local("virtualenv {0}".format(ENV_PATH))

def _del_env():
    """Delete a virtual enviroment."""
    local("rm -rf {0}".format(ENV_PATH))

def _clone_pelican():
    """Clone Pelican from repository."""
    local("git clone {0}".format(PELICAN_REPOSITORY))

def _install():
    """Install Pelican in the virtual enviroment."""
    with lcd(PELICAN):
        local("{0}/bin/python setup.py install".format(ENV_PATH))

def _browse():
    """Browse the local Apache site."""
    local("firefox -new-window http://localhost/joedicastro.com 2>/dev/null &")

def _gen(autoreload=False):
    """Generate the site from source."""
    local("{0}/bin/pelican {2} -s {1}".format(ENV_PATH, CONFIG_FILE,
                                              "-r" if autoreload else ""))
def _clean():
    "Remove the output folder."
    local("rm -rf {0}".format(OUTPUT))

def _local_deploy():
    """Deploy to the local apache web server."""
    local("rm  -rf {0}".format(LOCAL_WEB))
    local("cp -r {0} {1}".format(OUTPUT, LOCAL_WEB))

def pull_pelican():
    """Update Pelican to last revision from repository."""
    with lcd(PELICAN):
        local("git pull")

def bootstrap():
    """Get Pelican and install it in a virtual enviroment."""
    with settings(warn_only=True):
        _del_env()
    _make_env()
    with settings(warn_only=True):
        _clone_pelican()
    _install()

def regen():
    """Regenerate the site from source."""
    _clean()
    _gen()
    _valid_HTML()
    _local_deploy()

@hosts("my_user@" + PROD)
def publish():
    """Publish into remote web server with rsync."""
    regen()
    _browse()
    if confirm("¿Estas seguro de querer publicarlo?"):
        rsync_project(PROD_PATH, OUTPUT + "/", delete=True)

def new(title):
    """Create a new blog article."""
    local("gedit --new-window {0}/site/source/blog/{1}.md 2>/dev/null &".
          format(ROOT_PATH, title.replace(" ", "\ ")))
    local("firefox --new-window {0}/index.html &".format(OUTPUT))
    _gen(True)

def img4web(delete=True, source=""):
    """Optimize .jpg & .png images and copy them into source pictures dir."""
    local("./img4web.py -d {0} {1} {2}".
          format(os.path.join(ROOT_PATH, "site/source/pictures"),
                 "--delete" if delete else "",
                 "-s {0}".format(source) if source else ""))

Ahora, veremos el funcionamiento básico que nos permite este script. Primero vemos las tareas que tenemos disponibles:

$ fab -l
    fabfile.py: A fabric script for generate my personal blog

Available commands:

    bootstrap     Get Pelican and install it in a virtual enviroment.
    img4web       Optimize .jpg & .png images and copy them into source pict...
    new           Create a new blog article.
    publish       Publish into remote server with rsync.
    pull_pelican  Update Pelican to last revision from repository.
    regen         Regenerate the site from source.

Veamos que hacen cada una de ellas:

bootstrap Si observamos el código, veremos que lo hace es, en este orden: eliminar cualquier entorno virtual previo, crear un entorno virtual nuevo, descargar Pelican desde el repositorio (si no lo hemos hecho anteriormente) e instalar Pelican dentro de este entorno virtual. Y todo esto en un solo paso, casi todos los comandos que explicaba en Pelican - Introducción e Instalación con solo teclear fab bootstrap. Así de fácil. Con este comando podemos tanto crear una instalación de Pelican desde cero, como actualizar la instalación de Pelican después de actualizar este a la última versión con pull-pelican. Siguiendo con nuestro ejemplo, lo que haría este comando es crear los directorios env y pelican dentro de myblog.com con el entorno virtual creado y pelican instalado.
```
$ fab bootstrap
```
img4web Este comando hace uso del script que describía en Optimizar imágenes para la web para hacer precisamente eso, reducir el peso de las imágenes que empleo en los artículos. Lo que hago es a medida que voy escribiendo el articulo es ir guardando las imágenes en el directorio raíz (en nuestro ejemplo, myblog.com/) y cuando lo termino, simplemente ejecuto el comando fab img4web y este me optimiza las imágenes, me guarda las optimizadas en el directorio de imágenes del contenido (myblog.com/site/source/pictures/) y me elimina las imágenes originales del directorio raíz. Cuando termina me muestra un resumen con la cantidad de imágenes procesadas y el ahorro en espacio conseguido. Espacio en disco ahorrado que se resume en menos ancho de banda consumido y en páginas web que se cargan más rápido.
```
$ fab img4web
```
new Con este creo o edito los artículos del blog. Realiza tres funciones: me abre una venta de Gedit con el articulo que le indico con la extensión .md, me abre una ventana de Firefox que me muestra el fichero index.html del directorio del sitio generado por Pelican (myblog.com/site/output/index.html) y finalmente me activa Pelican con la opción autoreload. Luego empleando el plugin Grid de Compiz, divido la pantalla en dos mitades y coloco a la izquierda Gedit y a la derecha Firefox. Esto me permite, como explicaba en De Drupal a Pelican editar el contenido y previsualizar el resultado casi en tiempo real, disponiendo al mismo tiempo de un buen corrector ortográfico.
```
$ fab new:"Articulo de prueba"
```
publish El más importante, el que sube los artículos al servidor web. Publicar el contenido de la web es tan sencillo como ejecutar este comando. Lo que hace es regenerar el contenido (por si hubiera algún cambio sin guardar) y luego mostrarme el resultado en firefox. Pero el resultado que me muestra no es el del directorio de salida de Pelican, si no de una copia que tengo en un servidor Apache local. Esto me permite ver los cambios de manera más fiel a la versión web, puesto que hace uso del fichero .htaccess y de las reglas que tengo establecidas en él. Finalmente me pregunta si realmente deseo publicar el contenido, por si se me hubiera escapado algo. Si le digo que no, aborta la publicación, pero si le digo que si, me sincroniza el contenido de la carpeta local con la remota empleando rsync. De esta manera solo se transmiten los ficheros nuevos, se borran los que se hayan eliminado en local y solo transmite la parte que haya cambiado de los archivos modificados. Gracias a esto, modificar o añadir contenido es cuestión de segundos. Y sencillisimo.
```
$ fab publish
```
pull_pelican Nos sirve para actualizar Pelican a la última revisión disponible en el repositorio oficial. Si después de ejecutarlo, queremos instalar la nueva versión en nuestro entorno virtual para poder emplearla, simplemente tenemos que volver a ejecutar fab bootstrap y todo se realizará de forma automática.
```
$ fab pull_pelican
```
regen El proceso principal, es el que le pide a Pelican que genere el sitio web a partir de nuestro directorio de origen. También realiza varios procesos: primero eliminar el directorio de salida actual (para tener una copia fresca), genera el nuevo contenido, luego procesa los archivos para que validen en HTML5 y finalmente hace una copia del directorio de salida a mi servidor local Apache. El procesar los archivos para validar en HTML5 se debe a que markdown crea unos enlaces rel = "footnote" y rev = "footnote" en las notas al pie que se han quedado obsoletos y no son necesarios. De momento es un post-procesado, pero puede que finalmente modifique Pelican para que se haga en tiempo de generación del sitio. Aunque creo que el rendimiento de esta manera sería menor que emplear el comando sed que ejecuta este proceso, será cuestión de probarlo. También se podría modificar markdown.

Con solo 6 comandos tengo automatizadas todas las tareas básicas para administrar y crear contenido en mi blog. Ni siquiera el potente y buenísimo drush de Drupal me permitía este nivel de automatización (aunque se acercaba bastante). De esta manera solo me tengo que preocupar de crear artículos y de las posibles personalizaciones que le quiera realizar al tema del sitio. Me olvido de todo lo demás, de todo lo que conlleva un CMS. Solo hay una manera de bloguear más cómoda para los que a estos les parezca algo complejo, servicios como Tumblr. Aunque si quieres tener el control sobre tu sitio, no conozco manera más cómoda y con más ventajas que esta.

Pelican - Creación de contenido

2011-06-27T18:27:00+02:00

Crear contenido con Pelican es lo más sencillo que uno pueda imaginarse. Por ejemplo, crear este articulo, se puede hacer del siguiente modo. Abrimos un editor de textos cualquiera (por ejemplo vi o gedit) y creamos un archivo nuevo llamado Pelican, con la extensión .md si queremos emplear Markdown o .rst si queremos emplear reStructuredText. Vemos como lo haría, para este blog en concreto. Este sería el texto para crearlo en formato reStructuredText:

Pelican - Creación de contenido
###############################

:tags: Pelican, python, markdown, reStructuredText, blog, HTML.

Crear contenido con **Pelican** es lo más sencillo que uno pueda imaginarse. Por 
ejemplo, crear este articulo, se puede hacer del siguiente modo. Abrimos un 
editor de textos cualquiera (por ejemplo vi o gedit) y creamos un archivo nuevo 
llamado Pelican, con la extensión *.md* si queremos emplear Markdown o *.rst* si 
queremos emplear reStructuredText.

Y este el que usaría para crearlo en markdown, que es el que yo empleo:

title: Pelican - Creación de contenido
tags: Pelican, python, markdown, reStructuredText, blog, HTML, Piwik, Disqus.

Crear contenido con **Pelican** es lo más sencillo que uno pueda imaginarse. Por 
ejemplo, crear este articulo, se puede hacer del siguiente modo. Abrimos un 
editor de textos cualquiera (por ejemplo vi o gedit) y creamos un archivo nuevo 
llamado Pelican, con la extensión *.md* si queremos emplear Markdown o *.rst* si 
queremos emplear reStructuredText. Vemos como lo haría, para este blog en 
concreto.

Ahora solo tendríamos que guardar este fichero en la carpeta raíz de nuestro contenido y ejecutar Pelican para generar la página web resultante. Así de sencillo. Por ejemplo, creamos una carpeta prueba dentro de la estructura de ficheros que habíamos creado en el articulo anterior (myblog.com/) y guardamos allí este fichero. Ahora ejecutamos pelican dentro del entorno virtual y nos creara una carpeta output donde como resultado tendremos un blog por defecto creado como por arte de magia. Es decir, hacemos esto:

$ mkdir prueba
$ vi prueba/pelican.md
$ source  env/bin/activate
$ pelican prueba/
$ ls
env  output  pelican  prueba  site  temp
$ firefox output/index.html

y obtenemos esto:

Estructura del articulo

En el ejemplo anterior lo único que varía entre ambos formatos (aparte de la sintaxis) es la cabecera del mismo. En la cabecera se incluye el titulo del mismo (no tiene porque coincidir con el nombre del fichero) y los metadatos. El titulo en reStructuredText va subrayado con símbolos # y en markdown es un metadato más. Excepto el título, todos los metadatos son opcionales. Los metadatos en .rst van precedidos de dos puntos :. Después de los metadatos es suficiente con dejar una linea en blanco para comenzar a redactar el contenido de nuestro articulo.

Los metadatos que se pueden incorporar son los siguientes:

title (solo como metadato en markdown): Es el titulo del artículo o página.
date: Es la fecha y hora de publicación. Si no se indica, tomara como tal los valores del propio fichero de texto. El formato es el siguiente: año-mes-dia hora:minutos, es decir, %Y-%m-%d %H:%M
category: La categoría en la que queremos englobar el articulo. Si no se especifica, puede coger la categoría por defecto que se haya especificado en el fichero de configuración si así se ha establecido (por defecto es misc). Otra forma aún más simple, es crear un directorio dentro de nuestro directorio de contenido y colgar los archivos dentro de él. Todos los que se encuentren dentro de ese directorio caerán en la categoría que coincida con el nombre del mismo. Así es como yo lo hago, con un directorio llamado blog, es idoneo para organizar el contenido.

En el tema por defecto, las categorías se añaden como una entrada al menú superior que al ser seleccionada, muestra todos los artículos englobados dentro de ella.
author / authors: El autor(es) del articulo. Si se omite, escoge por defecto el que se haya establecido en el fichero de configuración. Yo lo omito, pero puede ser muy útil para blogs escritos por varios autores.
tags: Las etiquetas con las que etiquetamos a nuestro articulo. El tema por defecto solo nos permite seleccionar una y ver todos los artículos etiquetados de igual modo, pero es bastante sencillo crear una nube de etiquetas como la que empleo en este blog.
summary: Es el resumen que queremos que se vea del articulo cuando se emplea la paginación. Por defecto, si no se especifica este campo, los artículos se resumen con las primeras 50 palabras del mismo.
slug: Esta es uno de los campos más curiosos, pero al mismo tiempo más geniales. Este campo es el nexo que nos permite enlazar varias versiones del mismo articulo en distintos idiomas. En el tema por defecto, nos muestra las distintas traducciones de un articulo, si es que existen.
status: Esta es un campo especial que solo admite dos valores, draft (borrador) y published (publicado). Cualquier otro valor es ignorado. Si el valor es draft, el articulo o pagina no aparece publicado ni referenciado de algún modo al generar el contenido, y solo está disponible si accedemos a él a través del directorio drafts/. Esto es una ayuda para evitar que por un descuido subamos a la web un articulo sin terminar. Yo no lo empleo, ya veremos cuando hable de le automatización, como he resuelto este posible problema de otro modo. Si lo empleamos, deberíamos añadir el directorio drafts/ a nuestro fichero robots.txt como Disallow para que no fuera indexado por los buscadores (de poco importaría ocultar el el borrador si lo haces accesible a través del buscador).

Para comprender el resto de opciones disponibles para crear el contenido, voy a centrarme en el sitio de ejemplo que viene por defecto con Pelican. Empezaremos eliminando las pruebas que acabamos de realizar.

$ rm -r output/
$ rm -r prueba/
$ ls
env  pelican  site

Estructura del contenido del ejemplo

Ahora, en el directorio de contenido del sitio de ejemplo, tenemos la siguiente estructura de ficheros:

$ cd site/
$ tree source/
source/
├── another_super_article-fr.rst
├── another_super_article.rst
├── cat1
│   ├── article1.rst
│   ├── article2.rst
│   ├── article3.rst
│   └── markdown-article.md
├── draft_article.rst
├── extra
│   └── robots.txt
├── pages
│   └── test_page.rst
├── pictures
│   ├── Fat_Cat.jpg
│   ├── Sushi.jpg
│   └── Sushi_Macro.jpg
├── super_article.rst
├── unbelievable.rst
└── unwanted_file

Donde:

another_super_article-fr.rst y another_super_article.rst son dos versiones del mismo articulo en inglés y francés. Aunque cuelgan del directorio raíz, ambos están englobados dentro del sitio en la categoría bar a través del metadato category y enlazados traducciones mediante el metadato slug :slug: oh-yeah
draft_article.rst es un articulo que no aparece publicado en el sitio de ejemplo al estar marcado como borrador con el metadato status, pero al que podemos acceder igualmente a través de myblog.com/site/source/drafts/a-draft-article.html
super_article.rst y unbelievable.rst son ejemplos de uso de metadados. El primero es un articulo que cuelga de la categoría yeah y que sirve como ejemplo del empleo de summary y del uso de imágenes y código. El segundo es un ejemplo de articulo sin más metadatos que la fecha del mismo y de como cae en la categoría misc por defecto.
unwanted_file es un articulo que no se procesa de ningún modo por carecer de extensión que lo identifique como markdown o reStructuredText. Como consecuencia este fichero ni siquiera se copia al sitio web generado. Puede ser un truco útil para emplearlo como fichero de notas personales de cualquier tipo, por ejemplo un recordatorio de como hemos definido la estructura de archivos, una chuleta como usar marcado o reStructuredText, artículos pendientes, ...
cat1 Este directorio es un ejemplo de como todos los artículos que cuelgan de él son englobados dentro de la categoría cat1 de forma automática. Esto nos evita escribir el metadato category en cada uno de ellos y nos ayuda a clasificarlos en el directorio. Y nos muestra como se pueden mezclar archivos markdown y reStructuredText sin ningún tipo de problemas.
extra En esta carpeta (puede ser otra, es configurable) englobamos archivos que queremos incluir en el sitio, pero que no han de ser procesados. Como por ejemplo: .htaccess, .robots.txt, .humans.txt, ... Esto puede cambiarse en el fichero de configuración, especificando el origen dentro del directorio de nuestro contenido y la ruta en la que queremos que esté en el sitio web. En este caso, sería así en el fichero de configuración pelican.conf.py
```
FILES_TO_COPY = (('extra/robots.txt', 'robots.txt'),)
```
pages Serían las páginas estáticas del sitio, lo que no son artículos. Este nombre de directorio está reservado para esta función por defecto. Por ejemplo la página sobre mí que empleo en este blog, sería una de estas páginas estáticas. En estas páginas no están disponibles los comentarios. Si se especifica en el fichero de configuración, estas páginas aparecerán como entradas en el menú principal del tema por defecto.
pictures Este es uno de los directorios que se pueden emplear para albergar contenido estático como son las imágenes. Esto es configurable en el fichero de configuración. En este caso lo que se guardan en el son las imágenes empleadas en los artículos. Estas acabaran dentro del directorio static/pictures/ de nuestro sitio.

Y ya está, es una estructura muy sencilla y que genera un resultado bastante decente, comparado con los cientos de archivos que emplea (a parte de la BDD) cualquier CMS como Wordpress o Drupal.

Si partiéramos de un blog ya creado, Pelican proporciona una herramienta, que en nuestro caso estaría en /myblog.com/pelican/tools/importer.py y que nos permite importar artículos desde Wordpress o desde un fichero RSS y que nos genera los contenidos en reStructuredText. Si quisiéramos emplear markdown, existe una herramienta externa, html2markdown que nos permite obtener un texto en markdown desde una página web. Otra herramienta similar a esta última sería html2text.

No tiene más secreto que este, crear ficheros de texto plano en formato .md o .rst, guardarlos en el directorio que empleamos para albergar el contenido y generar el blog.

Pelican - Introducción e Instalación

2011-06-27T10:21:00+02:00

Pelican es un generador de sitios web con contenido estático. Está orientado originalmente a la creación de blogs. Pelican (Pelicano) es una anagrama de la palabra francesa Calepin que significa en español "cuaderno de notas" (blog). Su creador y desarrollador principal es el programador francés Alexis Métaireau. Y es la aplicación que genera el contenido para este blog. Personalmente le veo muchas ventajas frente a una plataforma de blogs convencional como Wordpress o Drupal, como ya comentaba en mi anterior articulo.

Pelican genera este contenido estático (páginas HTML) a partir de ficheros de texto plano formateados en un lenguaje de marcado ligero como Markdown o reStructuredText. También crea fuentes RSS y Atom de los artículos. Y dependiendo del tema empleado se pueden tener un archivo de los artículos publicados, clasificación por categorías, nube de etiquetas, un blogroll, enlaces a redes sociales, botón para tweeter, paginación, traducciones, etc. Aunque viene un tema completo por defecto y están disponibles algunos más, se puede crear uno completamente personalizado desde cero. La creación de estos temas se basa en el sistema de plantillas jinja2, lo que nos permite una gran flexibilidad. También disponemos de varios scripts que nos proporcionan soporte para comentarios con Disqus y de analíticas con Google Analytics ó Piwik. También nos permite generar ficheros PDFs de los artículos automáticamente y mostrar los enlaces a ellos, siempre que los artículos se hayan creado con reStructuredText.

Es un software muy joven, el primer commit en GitHub data del 13 de Agosto de 2010, pero que ha evolucionado bastante rápido y que aún sigue desarrollándose a un buen ritmo. Es posible que por esto aún tenga alguna carencia o algún que otro fallo, pero su autor es muy receptivo y acepta de buena gana las sugerencias, informes de errores y colaboraciones de desarrollo. Cuenta con una documentación bastante decente y actualizada. Alguno que otra cosa no está documentada, pero lo veo normal dado el ritmo de desarrollo y de a quien va orientado un software como este. Es muy sencilla su instalación y su utilización cuando se ha leído esta, pero será mejor que lo explique con un ejemplo sobre la marcha.

Instalación (para Linux)

La instalación del mismo es relativamente sencilla si no queremos complicarnos la vida, siempre tenemos la última versión disponible en el PyPi. Así que instalarlo podría ser tan sencillo como esto:

$ easy_install pelican

Aunque recomiendo emplear pip en lugar de easy_install, de este modo:

$ pip install pelican

De todos modos desaconsejo emplear este método, me parece mejor solución, dada la velocidad de desarrollo del software, emplear un entorno virtual para su instalación. Un entorno virtual nos permite tener una versión de Python independiente de la del resto del sistema, con sus propias librerías y con el software instalado que nosotros deseemos. Todo esto solo estará disponible cuando nos encontremos dentro de este entorno virtual, sin afectar al resto del sistema. Y podemos eliminarlo o des/activarlo cuando deseemos. Es bastante más sencillo de utilizar de lo que parece y es realmente potente.

Veamos, paso a paso, la forma en que yo lo instalaría.

Creamos una carpeta que contendrá Pelican, el entorno virtual y el sitio que crearemos. Yo le daría el nombre de la URL del blog, por ejemplo, myblog.com

$ mdkir myblog.com
$ cd myblog.com

Descargamos la revisión actual del repositorio de Pelican en GitHub. Esto nos creara una carpeta llamada pelican que contendrá una copia del repositorio en local (lo cual nos será muy útil en el futuro para actualizarlo).

$ git clone git://github.com/ametaireau/pelican.git
Cloning into pelican...
remote: Counting objects: 2603, done.
remote: Compressing objects: 100% (1143/1143), done.
remote: Total 2603 (delta 1541), reused 2420 (delta 1374)
Receiving objects: 100% (2603/2603), 687.30 KiB | 397 KiB/s, done.
Resolving deltas: 100% (1541/1541), done.

Ahora vamos a crear nuestro entorno virtual. En caso de no tener instalado pip o virtualenv, es rematadamente sencillo:

$ easy_install pip
$ pip install virtualenv

Voy a llamar env a nuestro entorno virtual. Lo creamos así.

$ virtualenv env
New python executable in env/bin/python
Installing distribute...........................................................
................................................................................
.......................................done.
$ ls
env  pelican

Ahora activaremos nuestro entorno virtual para "sumergirnos" dentro de él.

$ source env/bin/activate
(env)$

Vemos que aparece el nombre del entorno virtual entre paréntesis antes de la línea del prompt. Eso quiere decir que nos encontramos dentro de este entorno virtual. Ahora procederemos a instalar Pelican.

$ cd pelican/
$ python setup.py install

Ahora tenemos ya instalado Pelican, solo dentro de nuestro entorno virtual. Si probamos a llamar al programa fuera de él, veremos que no está disponible, luego necesitaremos activar este entorno cada vez que queramos emplearlo.

$ pelican
CRITICAL: you need to specify a path containing the content (see pelican --help for 
more information)

Nos da un error porque no le hemos pasado los parámetros necesarios. Ahora desactivamos el entorno y volvemos a llamar al programa y nos dice que no existe.

$ deactivate
$ pelican
pelican: orden no encontrada

Tenemos ahora dentro de myblog.com/ dos directorios, env y pelican. Podríamos borrar ahora el directorio pelican porque ya lo tenemos instalado dentro del entorno virtual, pero sería bueno conservarlo para poder actualizarlo en el futuro mediante git pull. Yo crearía una tercer directorio, site donde se alojaría nuestro sitio, organizado a su vez en tres subdirectorios:

source: sería la carpeta donde alojaríamos los archivos de texto de nuestro blog y todo aquello que quisiéramos que formara parte de nuestro sitio: imágenes, fichero .htacess, fichero robots.txt, páginas personalizadas...
output: El resultado del procesamiento de Pelican, es decir, nuestro blog.
theme : Sería el tema que usariamos para crear nuestro blog, en el estarían las plantillas jinja2, las hojas de estilo .css, el contenido estático (iconos, imágenes), ...

Luego, lo haríamos así:

$ cd ..
$ mkdir -p site/source
$ mkdir site/output
$ mkdir site/theme
$ ls site/
output  source  theme

Ya está, tenemos instalado Pelican y creada nuestra estructura para empezar a trabajar con él. Para eso nada mejor que crear un primer sitio de ejemplo. Entramos en el entorno virtual y creamos el sitio que viene de ejemplo con Pelican:

$ source env/bin/activate
$ pelican pelican/samples/content/ -o site/output -s pelican/samples/pelican.conf.py

Y ahora si abrimos el fichero myblog.com/site/output/index.html en un navegador, veremos algo como esto (en la imagen se ve la categoría cat1 seleccionada):

Es así de fácil de emplear Pelican, simplemente especificarle el directorio donde está el origen del contenido, el directorio destino y el fichero de configuración. Aunque con el fichero de configuración correctamente creado, solo será necesario indicarle la ubicación del mismo. Para comprender mejor la estructura y como funciona Pelican, sería buena idea copiar el tema, el fichero de configuración y el contenido que han generado este sitio de ejemplo a la carpeta site para no empezar nuestro blog desde cero.

$ cp -r pelican/samples/content/* site/source
$ cp -r pelican/pelican/themes/notmyidea/* site/theme/
$ cp pelican/samples/pelican.conf.py site/

En próximos artículos veremos como crear artículos, publicar el sitio, personalizar el tema y automatizar todos estos procesos para hacerlo todo mucho más sencillo.

De Drupal a Pelican

2011-06-22T02:10:00+02:00

Este blog no está realizado con ningún CMS, ni siquiera utiliza BDD alguna, es simplemente HTML + CSS y nada más. Es decir, es contenido estático, no dinámico. Hasta hace 3 días estaba funcionando con el mejor CMS PHP que conozco, Drupal. Pero persiguiendo el camino hacia el minimalismo y la productividad (fiel al espíritu KISS) que ya inicie cuando comencé a escribir todos mis artículos en Drupal con Markdown, el siguiente paso era evidente. La pregunta era muy sencilla, si un blog consta de contenidos que rara vez cambian (exceptuando los comentarios) ¿para que necesito un gestor de contenidos dinámicos?

La respuesta es fácil, para nada. Actualmente, gracias a servicios como los de Disqus, Livefyre, IntenseDebate ó Echo es posible externalizar el único contenido dinámico básico de un blog, los comentarios. Todo lo demás puede ser contenido puramente estático, solo HTML y CSS, sin renunciar a prácticamente nada de lo que nos ofrece un blog basado en un CMS como Wordpress o Drupal. Se pueden emplear scripts externos en javascript si se desea, o insertarlos dentro del HTML. Lo que nos permite implementar lo mismo que en un blog normal. Además se puede disponer también de feeds RSS y Atom.

Elegir un generador de contenido estático

Evidentemente la idea no es crear las paginas HTML a mano, ni de broma, lo lógico era seguir empleando la misma estrategia que ya había iniciado con Drupal, emplear solo ficheros de texto en formato Markdown que nos generarán el HTML necesario de forma automática. Entonces lo que tenía que encontrar era un software que me permitiera hacer lo mismo que Drupal, pero sin toda la parafernalia que rodea a un CMS. Un generador de sitios web estáticos (a partir de markdown) y que a ser posible estuviera escrito en Python, mi lenguaje favorito. Como ya adelante en el artículo sobre Markdown, existen varias opciones:

Pelican de Alexis Métaireau, que emplea en su propio blog
Blogofile de Ryan McGuire que también lo usa en su blog
Hyde de Lakshmi Vyas. Su blog con Hyde también.
rstblog de Armin Ronacher. Solo permite reStructuredText, con él crea su blog, un ejemplo de elegancia y calidad.

Bueno, tenía varias posibilidades, solo tenía que elegir una que se adaptara mejor a mis necesidades. De entrada descarté rstblog porque no permitía el empleo de markdown, cuando los otros permitían tanto .rst como .md como formatos de entrada. Solo me quedaban 3 candidatos. Así que lo primero que hice antes de nada, fue buscar blogs creados con cada uno de ellos, para ver que posibilidades reales ofrecían. Encontré ejemplos de blogs de mucha calidad de todos ellos. Aunque enseguida me di cuenta de una cosa, en dos de ellos los mejores blogs lo eran porque tenían una elevada personalización detrás (artículos de sus autores contándolo). Y curiosamente con el tercero, casi todos preferían quedarse con la configuración estándar, sin tocar prácticamente nada, y la verdad es que el resultado era bastante decente. Luego miré que cargaba cada uno de ellos en la página de entrada, y volvía a repetirse la misma tendencia. En los dos primeros vi demasiadas hojas de estilo, imágenes y demasiados scripts javascript, en el tercero, nuevamente se cargaban menos elementos. Finalmente comparé características, modo de funcionamiento y le eché un vistazo rápido al código. La impresión era otra vez la misma, dos de ellos, Hyde y Blogofile aunque aparentemente potentes, los veía innecesariamente complejos, en cambió Pelican era bastante más sencillo. Otra forma de determinar su repercusión era contar el número de descargas de cada una de las aplicaciones desde PyPi. Los números son los siguientes (a 27 de Junio de 2011), obtenidos con Vanity o pythonpackages.com:

Paquete	Descargas	Descargas (2 de Diciembre de 2011)
Blogofile	2.419	3.854
Hyde	1.945	4.518
Pelican	3.919	6.138

La elección final era Pelican y no me arrepiento en absoluto, la prueba es que esté blog está funcionando gracias a él (Gracias Alexis!). Aunque las otras dos son también muy buenas opciones, y seguramente serían la primera opción para más de uno. Y siempre podría cambiar fácilmente, porque el contenido seguiría estando guardado en ficheros de texto con marcado markdown.

No entraré en detalles ahora de como instalar y emplear Pelican, eso lo dejo para otro próximo articulo, Pelican. Pero si voy a hacer un repaso de los pros y los contras de emplear Pelican frente a un CMS como Drupal para crear un blog.

Ventajas de Pelican vs CMS

Solo ficheros de texto, No BDD

Simplemente te tienes que preocupar de eso, ficheros de texto, es donde guardas el contenido que creas. Todo lo demás lo genera Pelican por ti. Nada de crear y gestiónar bases de datos, ni copias de seguridad de la misma y un montón de espacio y recursos desaprovechado solamente para generar dinámicamente el mismo contenido que te genera Pelican.

Mejor rendimiento, carga de página más rápida

Generar contenido dinámico es más caro en recursos y es más lento (consultas a la BDD). Sobre todo a medida que llenas tu CMS de personalizaciones y plugins. ¿Que hacen prácticamente todos los sistemas de caché?, generar contenido estático para luego servirlo más rápidamente. ¿No es un poco estúpido crear contenido que apenas cambia en el tiempo, en un sistema dinámico que genera ese contenido cada vez y que para mejorar su rendimiento lo convierte en estático? Y ya no hablemos de las múltiples hojas CSS, scripts javascript y enlaces a contenido externo que cargan la mayoría de los CMS por defecto. Cada plugin que añadimos pone su granito de arena y optimizar todo esto requiere dedicación y esfuerzo (o seguir sumando aún más plugins en el mejor de los casos). Con Pelican ya tienes directamente el contenido estático y menos recursos que descargar. En este blog, sin contar con los ficheros javascript de Disqus y Piwik, lo único que se descarga es un fichero HTML, una hoja CSS y las imágenes que se incluyen en los artículos (cuando las hay). Es decir sirves el mismo contenido pero generando menos tráfico desde tu servidor.

Soporta mejor el tráfico

Cuando un sitio web soporta mucho tráfico, emplear un CMS requiere de mucha optimización y generalmente de mucha maquina o complejas instalaciones. Y la base principal siempre es un sistema de caché que sirva contenido lo más estático posible. Se cachea todo lo que se puede, y si es en memoria mejor. Las BDD son un problema aparte, desde soluciones NoSQL a clusters o BDD distribuidas. Con contenido estático no te tienes que preocupar de optimizar los accesos a la BDD, solo de tener un buen servidor web y si quieres, cachear en memoria o ampliar máquina. Pero poco más.

Seguridad

Olvídate de problemas de seguridad, los únicos agujeros de seguridad de un sitio con contenido estático están del lado del servidor web, de todo lo demás, te olvidas. Establece bien los permisos en el sistema de ficheros y punto. El único contenido dinámico del sitio (javascript) ni siquiera es algo que deba preocuparte, es algo externo que le concierne a Disqus o al sistema de analíticas web que elijas (Google Analytics o Piwik).

Olvidarse de gestionar un CMS. Mantenimiento mucho más sencillo (nulo)

Instalar el CMS, crear la BDD, encontrar, instalar y probar los plugins que necesitas, actualizaciones, actualizaciones de seguridad, personalizaciones, temas... Todo lo que rodea a cualquier CMS. Y ya no digamos si hablamos de un CMS potente y complejo como Drupal, con cientos de posibilidades. Y sin olvidar toda la basura que se va acumulando en las BDD tras varias actualizaciones y múltiples pruebas de plugins, con Pelican siempre tienes un sistema limpio. Todo eso lo olvidas con Pelican, lo instalas, personalizas y automatizas una sola vez, luego te olvidas de todo lo que no sea escribir (si quieres, nada te impide seguir cambiándolo y mejorándolo). Emplea tú tiempo en crear contenido.

Backups más sencillos

Con un CMS deberías hacer Backups del servidor web tanto del sistema de ficheros como de la BDD. Y sería aconsejable tener un servidor web local montado para probar los cambios que vayas a hacer en el CMS sin miedo a romper nada. Con Pelican ni siquiera necesitas hacer Backups del servidor ni del contenido web. Todo lo que necesitas para generarlo ya está en tu ordenador en esos ficheros de texto. Incluso si empleas un tema propio, también está en tu equipo. Así que las copias de seguridad de tu sitio web no son distintas a las que regularmente ya haces de tu ordenador personal.

Hosting en cualquier sitio

Solo tienes que alojar contenido estático, no necesitas BDD ni soporte para ningún lenguaje o librería en particular. Puedes hasta utilizar recursos gratuitos como las páginas de GitHub o BitBucket o un sistema de ficheros en la nube económico como Amazon S3 (o Amazon CloudFront). Solo necesitas eso, servir ficheros, nada más. Hasta el hosting más económico te sirve.

Emplear un CVS para gestionarlo

Poder emplear Git o Mercurial o cualquier otro CVS para gestionar los cambios del blog no tiene precio. Ningún sistema de revisiones de CMS es tan potente. Además tienes la posibilidad de crear un hook para que al enviar un commit después de crear un articulo (o realizar un cambio) se suba el contenido automáticamente al servidor. Con esto realizar cualquier cambio o revertir un error es algo trivial. Además te permite subir una copia a un sitio como GitHub o BitBucket y tenerlo siempre disponible en cualquier sitio con conexión a la red. Como maravillosa opción, esto permite que el contenido de un blog, incluso de un mismo articulo, sea editado por más de una persona de manera bastante más sencilla, potente y menos propensa a errores que con un CMS.

Crear los articulos off-line

Eso te permite ir creando los artículos al ritmo que te de la gana, cuando quieras y en cualquier sitio con un portátil. No necesitas estar conectado a la red. Esto también puede hacerse con un CMS, pero suele ser más complejo (exceptuando emplear cortar y pegar) e inseguro (si se habilita el envío remoto de artículos). Yo lo había logrado en Drupal empleando markdown, pero seguía necesitando un segundo paso on-line para personalizar las etiquetas.

Edición de artículos más cómoda

Puede parecer que un CMS con su editor WYSIWYG es más cómodo, pero todo lo contrario. Ya lo comentaba en el artículo sobre markdown. Pero es que además me proporciona una mejor experiencia de edición y más potente. Explico como redacto yo los artículos para que se entienda mejor. Divido la pantalla en dos mitades, a la izquierda el editor de textos y a la derecha el navegador. Como editor de textos empleo Gedit, que tiene resaltado de texto para markdown y un corrector ortográfico (por esto no uso vim para esto) bastante mejor que el de Firefox (que solo examina el texto hasta cierto número de casos dudosos). Además Pelican tiene una maravillosa opción, autoreload que lo hace correr en segundo plano y cuando detecta un cambio en uno de los ficheros, vuelve a generar el contenido. Entonces en gedit le digo que autoguarde el contenido cada 3 minutos (o a voluntad, manualmente) y cuando Pelican lo detecta, automáticamente regenera los ficheros HTML. Como navegador empleo Firefox y tengo, abierto en una pestaña, el fichero index.html que genera Pelican y empleando la extensión Auto Reload el contenido de la página (en local) se actualiza automáticamente al detectar un cambio en el fichero. Es decir, como en la primera página se puede ver el contenido completo del último articulo, lo que estoy viendo es una previsualización automática del contenido en la página cada 3 minutos. Y todo esto en off-line, sin estar conectado a internet. Esto si es un verdadero editor WYSIWYG, y no los otros. Además, que demonios, los navegadores no se diseñaron para crear texto, cualquier editor de texto es más potente.

Control del Spam

El Spam, esa lacra que azota toda la web. En Pelican, ese problema, lo tiene que gestionar Disqus, no tú. Tú solo tienes que gestionar el poco que se le escape. Pero el buscar un plugin, configurarlo y que funcione bien, es algo de lo que no tienes que preocuparte. En Drupal tenía este asunto solucionado, pero fue cosa de probar varios plugins, hasta que al final di con uno que me lo solucionaba de verdad.

Recursos de CPU y RAM

El contenido dinámico consume mucha más memoria RAM y CPU en el servidor que servir contenido estático. Al fin y al cabo, en el caso del contenido estático, es poco más complejo que servir ficheros. Si tienes que compartir el servidor con más proyectos, agradecerás no tener que emplear un CMS para servir el blog.

Resaltado de Sintaxis incorporada con Pygments

Mientras en la mayoría de CMS necesitas un plugin para habilitar el resaltado de sintaxis para código fuente, en Pelican esto viene por defecto empleando el excelente Pygments

Cumplimiento de Estándares Web

Con Pelican es relativamente sencillo configurar el tema para que cumpla los estándares web y genere contenido valido. Y una vez que lo haces, es para siempre, a no ser que modifiques algo en el tema, todo el contenido que generes cumplirá con los estándares (a no ser que incluyas HTML dentro que no lo sea). De este modo, este sitio valida HTML5, CSS3 y genera feeds RSS y Atom validos. Conseguir esto con un CMS y empleando editores WYSIWYG es bastante más complejo y doloroso. Aunque yo lo había conseguido con Drupal y markdown, tuve que modificar un tema casi por completo, casi como crearlo desde cero.

Inconvenientes de Pelican vs CMS

Comentarios sin resaltado de sintaxis

Algo que me permitía Drupal y no me permite Disqus (por ahora) era emplear markdown en los comentarios y resaltado de sintaxis para el código fuente. Es el mayor inconveniente que he encontrado hasta ahora. Pero bueno, tampoco es algo imprescindible y esperemos que Disqus lo soporte en un futuro.

Sitemap

Tampoco Pelican genera sitemaps en xml para los buscadores. Aunque tampoco es algo imprescindible y Drupal tampoco lo soporta por defecto, si no a través de un módulo. El autor lo tiene como tarea pendiente, y si tarda mucho, a lo mejor me animo y lo creo yo mismo.

Personalización más sencilla para non geeks

Esta es la parte que menos me afecta, pero es el gran inconveniente para la gran mayoría sin conocimientos avanzados. Aunque Pelican no es difícil de instalar y configurar, si queremos personalizarlo bastante, la cosa cambia. Los CMS son mucho más sencillos en ese sentido, pero el coste a pagar por otro lado no me compensa.

No tiene búsqueda incorporada

Es otro pequeño inconveniente que puede suplirse empleando la de Google AdSense en el sitio, por ejemplo. Personalmente no me importa demasiado, teniendo disponibles en el sitio recursos como el archivo de todos los artículos publicados o la nube de etiquetas.

No puedes personalizar el contenido dinámicamente

Con un CMS puedes hacer cosas como mostrar un contenido o un tema distinto según el perfil del usuario, o según la carga del servidor, etc. Con contenido estático lógicamente no puedes hacer esto. A mi me da igual, no lo necesito, es solo un blog.

Llevo varios años empleando Drupal en varios sitios y me sigue pareciendo un CMS excelente y una buenísima opción para generar contenido dinámico para no desarrollladores (de otro modo prefiero un framework como Django). Pero actualmente, para crear blogs, si se tienen conocimientos suficientes, emplear un CMS me parece una decisión poco acertada, es matar moscas a cañonazos. Hoy en día hay soluciones como Pelican y las mencionadas arriba (y otras alternativas en otros lenguajes) que te permiten crear blogs con facilidad, centrándote únicamente en crear los artículos y automatizar todo lo demás. ¿Acaso esa no es la razón principal del grandisimo éxito de twitter o tumblr? La inmediatez de los resultados y la delegación de la gestión a terceros, tú solo escribes. Pelican te permite lo mismo, solo requiere la personalización inicial y listo, con la ventaja añadida de que puedes personalizarlo a tu gusto y hasta donde te dé la gana o seas capaz.

Notificaciones de escritorio en Ubuntu desde Python

2011-06-12T23:05:00+02:00

En Ubuntu¹ las notificaciones de escritorio son esos cuadros emergentes que nos proporcionan información sobre algún evento que se está produciendo en nuestro equipo (llegada de un email, canción que se está reproduciendo, cambio de volumen, estado de batería, etc). Sustituyen a las ventanas de dialogo que normalmente requieren la intervención del usuario para cerrarlas y son más molestas. Además frente a las ventanas de dialogo tienen la gran ventaja de que son gestionadas a través de una cola. Es decir, que si hay varias notificaciones para mostrar, no se muestran todas a la vez llenándote todo el escritorio de pequeñas ventanas, se van mostrando una después de otra. La notificaciones aparecen en una esquina del escritorio y se desvanecen por si solas al cabo de unos segundos. Son muy útiles porque llaman nuestra atención y nos informan sin interrumpir nuestro trabajo.

En Ubuntu esta operación la realiza el paquete Notify OSD que se basa en las especificaciones del proyecto Galago (freedesktop.org Desktop Notifications Specification). Este emplea el demonio notify-osd para enviar las notificaciones a través de D-Bus. Sin embargo muchos paquetes aún emplean la librería libnotify del proyecto Galago para enviar sus notificaciones. Además el proyecto Galago tiene un binding para Python de está librería, que es lo que emplearé en este artículo. En Ubuntu, es el paquete python-notify y se importa desde Python como pynotify. También es posible emplear el paquete libnotify-bin que nos proporciona el comando notify-send que nos permite enviar notificaciones directamente desde la línea de comandos, algo que puede ser muy útil para scripts en bash.

Ejemplo de utilización de notify-send:

$ notify-send "Notificación" "Esto es un ejemplo de notificación"

que nos mostraría una notificación como esta:

Notificaciones desde Python

Empleando pynotify podemos emplear estas notificaciones en nuestros programas y scripts Python y se visualizaran igual que las propias del sistema. El problema que tiene este modulo es que no tiene documentación AFAIK, por lo que tenemos que guiarnos por algunos ejemplos (los del propio paquete, por ejemplo) o experimentar con él ayudándonos de las herramientas de introspección de Python (help(), dir(), inspect).

Para poder emplearlo en mis programas he creado una función que hace uso de las opciones principales de las notificaciones:

import pynotify
import gtk

def notify(title, msg, icon=None):
    """Send notification icon messages through libnotify.

    Parameters:

    (str) title -- The notification title
    (str) msg -- The message to display into notification
    (str / uri) icon -- Type of icon (ok|info|error|warm|ask|sync) or icon file

    """
    if not pynotify.is_initted():
        pynotify.init(title)
    gtk_icon = {'ok':gtk.STOCK_YES, 'info':gtk.STOCK_DIALOG_INFO,
                'error':gtk.STOCK_DIALOG_ERROR, 'warm':gtk.STOCK_DIALOG_WARNING,
                'ask':gtk.STOCK_DIALOG_QUESTION, 'sync':gtk.STOCK_JUMP_TO}
    try:
        note = pynotify.Notification(title, msg)
        helper = gtk.Button()
        gtk_icon = helper.render_icon(gtk_icon[icon], gtk.ICON_SIZE_BUTTON)
        note.set_icon_from_pixbuf(gtk_icon)
    except KeyError:
        note = pynotify.Notification(title, msg, icon)
    note.show()

Básicamente llamamos a la función y le decimos que titulo le queremos poner, el mensaje y el icono que queremos mostrar. En cuanto al icono se puede emplear ninguno, uno personalizado indicando la ruta al fichero o un icono estándar de GTK para las opciones más comunes. Veamos lo sencillo de su funcionamiento con ejemplos:

>>> # Notificación sin icono
... notify("Titulo", "Esta notificación no lleva icono")
>>>

>>> # Notificación con icono personalizado
... notify("Ubuntu", "Esta lleva el icono personalizado",
"/usr/share/icons/gnome/scalable/places/ubuntu-logo.svg")
>>>

>>> # Notificación de información (GTK)
... notify("Información", "Esta emplea el icono de información estándar de GTK", "info")
>>>

>>> # Notificación de error (GTK)
... notify("Error!", "Ejemplo de reporte de error (GTK)", "error")
>>>

Como se puede ver el proceso es realmente sencillo y hacer esto puede aportar a nuestros programas/scripts ese toque que le faltaba y que tanto contribuye a la usabilidad de los mismos. Yo por ejemplo, lo empleo en scripts programados para saber cuando se activan y cuando terminan, sobre todo cuando son procesos largos. Un ejemplo puede verse en el código de Sincronizar una carpeta local y una remota a través de FTP: lftp-mirror

El fichero con este código, notify.py se encuentra en mi repositorio.

Se puede emplear también en otras distribuciones Linux ↩

Algoritmos Shuffle

2011-06-09T23:35:00+02:00

Los algoritmos shuffle se emplean para barajar o desordenar los elementos de una lista (como si fueran las cartas de una baraja) al azar. Se intenta reproducir lo que ocurre en la realidad cuando barajamos un mazo de cartas o extraemos bolas de un bombo para formar una combinación. El comportamiento ideal de estos algoritmos debe de ser imparcial, es decir que todas las posibles permutaciones de esta lista tengan las mismas oportunidades de aparecer como resultado. Este reparto uniforme es clave para el buen funcionamiento del mismo, pues de no ser así se crearían tendencias y el resultado seria predecible, lo que acabaría con la aleatoriedad que se pretende conseguir.

Imaginemos tres distintas cartas de una baraja inglesa: As, Rey y Reina (Ace, King & Queen) como una lista en Python, y ahora veamos todas las posibles permutaciones de la misma (n!, es decir, 3! = 6):

Representación gráfica de las distintas permutaciones.¹

>>> lista = ['A', 'K', 'Q']
>>> import itertools
>>> for i in itertools.permutations(lista):
...     print(i)
...
('A', 'K', 'Q')
('A', 'Q', 'K')
('K', 'A', 'Q')
('K', 'Q', 'A')
('Q', 'A', 'K')
('Q', 'K', 'A')
>>>

Vemos entonces que existen 6 permutaciones posibles que pueden darse como resultado de barajar las cartas. Ahora imaginemos que escogemos una estas permutaciones, y jugamos a barajar las cartas una y otra vez partiendo siempre desde esta permutación. Como ya adelantábamos, si el algoritmo shuffle fuese perfecto, el resultado de estas operaciones debería repartirse de forma imparcial (equiprobable) entre las distintas permutaciones posibles. Es decir, que al ejecutar un fragmento de código como el que sigue, donde empleamos el algoritmo shuffle que por defecto trae Python (en el modulo random de la librería estándar), ramdom.suffle()

>>> from random import shuffle
>>> for i in range(12):
...     lista = ['A', 'K', 'Q']
...     shuffle(lista)
...     print(lista)
...
['A', 'K', 'Q']
['K', 'Q', 'A']
['A', 'K', 'Q']
['Q', 'A', 'K']
['K', 'Q', 'A']
['Q', 'K', 'A']
['A', 'K', 'Q']
['Q', 'K', 'A']
['K', 'Q', 'A']
['K', 'A', 'Q']
['Q', 'K', 'A']
['Q', 'A', 'K']
>>>

los resultados en pantalla deberían irse repartiendo a partes iguales entre las distintas permutaciones. Del mismo modo, si ejecutáramos este algoritmo 600.000 veces sobre la misma permutación, los resultados deberían repartirse de esta forma:

Donde las apariciones de cada permutación posible son idénticas, es decir, 600.000/6 = 100.000. Pero veremos que en la realidad ocurre algo distinto, como ya podíamos adivinar al ver los resultados del código anterior. Veamos con detalle que es lo que ocurre con el algoritmo shuffle para ese mismo número de ejecuciones.

Como podemos ver, el comportamiento real de un algoritmo shuffle no se ajusta al comportamiento ideal. Unas combinaciones están sobre-representadas como QAK y KQA y el resto sub-representadas, siendo la combinación AQK la más cercana a los valores ideales. Pero estos valores no debemos verlos como una tendencia, puesto que si volvemos a ejecutar otras 100.000 operaciones de barajado, aunque seguirá sin ser un reparto equitativo, si es imparcial en cuanto que no se repiten las mismas desviaciones por permutación. Es decir, unas veces unas serán unas permutaciones las más sobre-representadas (y viceversa) y otras lo serán otras distintas, no hay una tendencia clara. Las variaciones en este caso oscilan entre 99.678 (-322) y 100.446 (+446) apariciones sobre un valor ideal de 100.000 con una desviación media de ±0.039%, unos valores no ideales pero si muy razonables y más que suficientes para la mayoría de necesidades.

Es importante volver a incidir en que un algoritmo de barajado bien diseñado siempre ha de ser imparcial, de hecho random.shuffle lo es, si no será erróneo y nos creara tendencias que pueden pasar inadvertidas a no ser que se comprueben correctamente (en este caso de forma estadística). Tendencias que pueden suponer un verdadero problema y echar al traste todos los cálculos y procesos que empleen este algoritmo como base. El emplear un algoritmo de barajado erróneo le ha causado más de un disgusto a algún casino online, ya que las tendencias permiten predecir el resultado de el barajado y usarlo para hacer trampas en el juego.

Pero si random.suffle es imparcial, ¿por qué no se reparten los resultados de manera uniforme? El problema es aquí entra en juego un segundo actor, que independientemente de lo bien diseñado que este nuestro algoritmo shuffle, nos condicionará que el reparto sea uniforme o no. Este segundo actor es la aleatoriedad, lo que precisamente intentamos conseguir. Para que nuestro algoritmo funcione necesitamos que se elijan las cartas al azar para ir desordenándolas también al azar. Y es aquí donde está el problema, el que impide que random.shuffle tenga un comportamiento ideal, que los ordenadores y la aleatoriedad, no son buenos "amigos". No existe algo así como un generador de números aleatorios perfecto basado en software (si los hay casi perfectos basados en hardware), debido a que son deterministas al estar basados en formulas matemáticas. Por lo que empleamos lo que se denomina generadores de números pseudoaleatorios. Estos generadores pueden ser más o menos "perfectos", pero al no generar verdadera aleatoriedad, nos impiden que nuestro algoritmo consiga efectuar un reparto uniforme. Matemáticamente se ha demostrado que algunos algoritmos, como el que emplea ramdon.shuffle (luego aclararemos cual es) tienen un funcionamiento ideal, y de hecho podemos acercarnos muchísimo al modelo ideal cuando empleamos un generador de aleatoriedad por hardware (que se acerca mucho a la verdadera aleatoriedad). Al final, aunque sean matemáticamente correctos, tu algoritmo de barajado será tan bueno como lo sea tu generador de números aleatorios.

Python, en su modulo random, emplea por defecto uno de los mejores generadores de números pseudoaleatorios existentes actualmente, el Mersenne twister (hasta la versión 2.4 se empleaba el Wichmann-Hill, que sigue disponible como clase) y está implementado en C. Los resultados entregados por él son muy fiables (excepto para su empleo en criptografía), generando números float con una precisión de 53 bits y con un elevado periodo de 2¹⁹⁹³⁷-1. Otra buena opción que nos ofrece el modulo random para entornos Unix/Linux es la clase random.SystemRandom() que nos ofrece la entropía generada por os.random() que a su vez la toma de la generada en /dev/random. Esta es una fuente bastante decente de aleatoriedad que en las pruebas me ha ofrecido resultados similares a el generador por defecto en Python.

Los algoritmos

Utilizar la función random.shuffle() es la forma más cómoda de barajar una lista en Python, y desde luego la más recomendable. Pero si quisiéramos desarrollar nuestro propio algoritmo, esta es una de esas ocasiones en las que o tienes unos solidos conocimientos matemáticos (o estadísticos) o mejor no intentes reinventar la rueda, recurre a lo conocido y solido, y como mínimo prueba siempre que los resultados que obtienes son lo que tu esperas. Esto no es una afirmación gratuita, esta es una de las ocasiones en la que la diferencia es tan sutil, que es facilísimo equivocarse sin siquiera darse cuenta. Veamos porqué.

La intuición a veces nos engaña, no seas ingenuo!

Aparentemente barajar una lista es de lo más sencillo, después de razonar un poco, podríamos acabar con un código parecido a este:

def faulty(lst):
    "An example of a intuitive but very bad algorithm."
    lst_length = len(lst)
    for i in range(lst_length):
        j = random.randrange(lst_length)
        lst[i], lst[j] = lst[j], lst[i]

Que aparentemente debería ser correcto, algo que han pensado muchos programadores ingenuamente hasta caer en la cuenta "a la fuerza" de que no es correcto. Es más, si por ejemplo nos limitáramos a ejecutarlo unas 360 veces para probarlo (las cuales aparentemente no son pocas), veríamos que tiene un comportamiento muy parecido al que nos da la función random.shuffle:

Como podemos ver las desviaciones del valor ideal son muy similares y con una desviación media muy parecida, ±2.130% para shuffle y ±2.222% para nuestro algoritmo, faulty. Y creeríamos erróneamente que nuestro algoritmo funcionaría correctamente. Pero es que para comprobar que no haya tendencia alguna es necesario ejecutarlo, muchas, pero muchas veces (por encima de los cientos de miles), ya que a mayor número de repeticiones, más se manifiestan esas tendencias. Al mismo tiempo, cuantos más elementos tenga la lista, mayores son las desviaciones y la tendencia. Además, con este número de ejecuciones aún no observamos las tendencias reales que se manifestarán luego en lo sucesivo. Veamos unos ejemplos para 2.400.000 ejecuciones para nuestra lista de tres cartas y para otra a la que hemos añadido la Sota (Jack).

En el gráfico de la izquierda ya se muestran claramente las diferencias, mientras la función shuffle varía entre -741 y +668 (sobre 400.000) con una desviación media de ±0.017%, nuestra función tiene una desviación media de ±1.869% (~110 veces superior) y varia entre -46.062 y +46.090. Como podemos ver es una autentica barbaridad. El gráfico de la derecha, nos confirma que a mayor número de elementos en la lista, mayores aún son las tendencias. Mientras que shuffle se sigue comportando correctamente con una desviación media de ±0.009% y varía entre -486 y +427 (sobre 100.000), nuestro pobre algoritmo se desmanda completamente, variando entre +31.326 y -25.254, una desviación media de ±0.541% (~61 veces más). Hay que tener en cuenta, que al ser mayor número de cartas, son 24 permutaciones, lo que nos da unas 4 veces menos repeticiones por permutación, es decir, que para tener el mismo número tendríamos que hacer 9.600.00 ejecuciones. Y como podemos ver, los resultados no son cuatro veces mejores, ni mucho menos, además sabemos que la tendencia se acentúa con el número de ejecuciones. Viendo estos resultados vemos claramente que determinadas permutaciones tienen muy pocas probabilidades de salir, cuando otras son altamente predecibles.

¿Entiendes ahora porqué no debes fiarte únicamente de tu instinto?

Vamos a conocer ahora los algoritmos que funcionan, están matemáticamente comprobados y son sobradamente conocidos (aunque a la vista está que no lo suficiente).

Fisher-Yates

Este algoritmo fue desarrollado por Ronald Fisher y Frank Yates en 1938² como un método a realizar con lápiz y papel. Para ello empleaban una tabla de números aleatorios calculada anteriormente para generar la aleatoriedad que necesitaban para el algoritmo. Este algoritmo esta comprobado matemáticamente y funciona correctamente siempre que la fuente de aleatoriedad sea completamente aleatoria. No deja de ser curioso, que un algoritmo que fue creado hace más de 70 años y que sigue actualmente vigente y presente en multitud de aplicaciones, sea al mismo tiempo desconocido por muchos desarrolladores, lo que les lleva a cometer los errores que comentaba anteriormente al implementar los suyos propios. Por eso como programadores deberíamos ser humildes y procurar no inventar siempre lo ya inventado y buscar siempre una solución previa para nuestros propósitos. Y probar, probar y volver a probar nuestro código...

La típica implementación del algoritmo en Python sería así:

def fisher_yates(lst):
    "Python implementation of the original Fisher-Yates algorithm."
    if len(lst) > 1:
        idx = len(lst) - 1
        while idx > 0:
            sel = random.randint(0, idx)
            lst[idx], lst[sel] = lst[sel], lst[idx]
            idx -= 1

Knuth-Durstenfeld

Este algoritmo es en realidad una variante del Fisher-Yates y fue publicado originalmente por Richard Durstenfeld en 1964³, pero fue popularizado por el genial Donald Knuth en el volumen 2 de su gran obra, The Art of Computer Programming, como el algoritmo P⁴. De ahí que sea generalmente conocido como Knuth-Durstenfeld o simplemente como Knuth Shuffle. Aunque curiosamente ninguno de los dos conocía anteriormente el trabajo previo de Fisher y Yates. Este algoritmo se ejecuta en tiempo polinómico lineal O(n), por lo que es muy eficiente.

Implementado en Python, sería algo así:

def knuth_durstenfeld(lst):
    "Python implementation of the Durstenfeld algorithm popularized by Knuth."
    for idx in reversed(range(1, len(lst))):
        # pick an element in lst[:idx+1] with which to exchange lst[idx]
        sel = random.randrange(idx + 1)
        lst[idx], lst[sel] = lst[sel], lst[idx]

Este algoritmo es el que está detrás de la función random.shuffle que hemos venido usando desde el principio del articulo. Lógicamente si está empleando el mejor algoritmo hasta la fecha, es absurdo implementar el nuestro propio cuando podemos usar esta función estándar de Python. De hecho el código de esta función es el siguiente:

def shuffle(self, x, random=None, int=int):
    """x, random=random.random -> shuffle list x in place; return None.

    Optional arg random is a 0-argument function returning a random
    float in [0.0, 1.0); by default, the standard random.random.
    """

    if random is None:
        random = self.random
    for i in reversed(xrange(1, len(x))):
        # pick an element in x[:i+1] with which to exchange x[i]
        j = int(random() * (i+1))
        x[i], x[j] = x[j], x[i]

Que como podemos ver, el algoritmo es el Knuth Shuffle.

A tener en cuenta

Conviene tener en cuenta una cosa, todos estos algoritmos modifican la propia lista in-place, es decir que no crean una nueva, y por lo tanto no devuelven ningún valor. Por lo tanto, no puedes asignar el resultado de una de estas operaciones a una variable, porque por defecto devuelven None. Es un error muy común, de hecho Mark Lutz lo define en su libro "Learning Python" como uno de los Common Coding Gotchas, es decir, uno de los errores más comunes en Python. Y dice claramente (pág. 388, cap. 15)

No esperes resultados desde funciones que cambien objetos en el sitio (sin crear nuevos objetos modificados). Y pone como ejemplos los métodos append, sort y reverse en listas.

Para verlo aún más claro, nada mejor que verlo con un ejemplo:

>>> from random import shuffle
>>> lista = [1,2,3]
>>> id(lista)  # Obtenemos el id del objeto (todo en Python es un objeto)
3077959916L
>>> shuffle(lista)
>>> lista      # La lista ya aparece barajada
[2, 3, 1]
>>> id(lista)  # Sin embargo vemos que el identificador es el mismo
3077959916L
>>> variable = shuffle(lista)  # Esto no tiene sentido, porque no se devuelve nada
>>> variable
>>> print(shuffle(lista))  # Aquí vemos que la función devuelve None
None
>>> id(lista)
3077959916L
>>> lista
[1, 3, 2]
>>>

En esta gráfica vemos los tres algoritmos comparados, los he ejecutado solamente 48.000 veces, para apreciar mejor las diferencias entre ellos.

Las desviaciones medias son de ±0.068% para Fisher-Yates, ±0.069% para Knuth-Durstenfeld y de ±0.554% para Faulty.

Sattolo-Cycle

Este algoritmo es muy parecido a los anteriores, pero con una significativa diferencia, este algoritmo solo genera ciclos, de ahí su nombre. Es decir, reparte uniformemente los resultados solo entre algunas permutaciones que se van rotando (aunque comparte el mismo problema con los anteriores al depender de una aleatoriedad no perfecta). Para resumir su funcionamiento, lo que hace es que después de ejecutarlo, ningún elemento de la lista repite la posición anterior que tenía en la misma. Ese algoritmo fue publicado por Sandra Sattolo en 1986

El algoritmo en Python:

def sattolo_cycle(lst):
    "Python implementation of the original Sattolo Cycle algorithm."
    idx = len(lst)
    while idx > 1:
        idx = idx - 1
        sel = random.randrange(idx)  # 0 <= sel <= idx-1
        lst[sel], lst[idx] = lst[idx], lst[sel]
    return

Podemos ver aquí un ejemplo de su funcionamiento al ejecutarlo sucesivamente sobre la misma lista, sin partir siempre de la misma permutación, para comprobar como ningún elemento conserva su posición anterior.

lista = ['A', 'K', 'Q']
>>> for i in range(12):
...     sattolo_cycle(lista)
...     print(lista)
...
['K', 'Q', 'A']
['A', 'K', 'Q']
['K', 'Q', 'A']
['A', 'K', 'Q']
['Q', 'A', 'K']
['A', 'K', 'Q']
['K', 'Q', 'A']
['Q', 'A', 'K']
['K', 'Q', 'A']
['Q', 'A', 'K']
['K', 'Q', 'A']
['Q', 'A', 'K']
>>>

El código de estos algoritmos y los test de rendimiento se encuentran en el fichero shuffle.py de mi repositorio

Aunque estos algoritmos no tienen un funcionamiento perfecto, debido al generador de números pseudoaleatorios, son validos para la mayoría de las aplicaciones para las que son necesarios, digamos que son lo suficientemente buenos para las aplicaciones prácticas de los mismos.

Otras fuentes para saber más

The Danger of Naïveté, Jeff Atwood
Shuffling, Jeff Atwood
Computers are lousy random numbers generators, Jeff Atwood
The intuition behind Fisher-Yates shuffling, Eli Bendersky
Ramdom.org

Diseño de las cartas por David Bellot. ↩
Fisher R., Yates F. [1938] (1943) Statistical Tables for Biological, Agricultural and Medical Research, 2nd edition, London, Oliver and Boyd, p. 23-24 ↩
Durstenfeld R.[1964] Communications of the ACM, vol. 7, issue 7(July) ↩
Knuth D.[1969] (1981) The Art of Computer Programming, 2nd edition, Addison-Wesley, pp. 139-140 ↩

Aplanar listas en Python

2011-06-02T00:35:00+02:00

Una lista multinivel o anidada es aquella que a su vez contiene otra(s) listas o tuplas (o generadores, en general cualquier iterable). Estas listas pueden a su vez contener otras, que a su vez puede contener otras, etc. Cada una de estas listas dentro de otra constituye un nivel de anidamiento. Un ejemplo sencillo puede ser el siguiente:

lista_anidada = [0, ['a', 'b', 'c'], 1, ['A', ('aA', 'bB', 'cC'), 'B'], 2]

Esta es una lista con dos niveles de anidamiento, porque la segunda lista dentro de la primera incluye a su vez dentro una tupla.

Dada una lista de estas características, en ocasiones necesitamos aplanarla, es decir tener todos los elementos dentro de una única lista sin anidamiento, una lista plana. Siguiendo con el ejemplo anterior, esta lista una vez aplanada quedaría del siguiente modo:

lista_aplanada = [0, 'a', 'b', 'c', 1, 'A', 'aA', 'bB', 'cC', 'B', 2]

Bien, ¿y como se consigue esto? Eso es precisamente lo que voy a tratar aquí, diversos métodos para aplanar una lista.

Listas anidadas a un solo nivel.

Un primer modo de hacer esto podría ser emplear una función similar a esta:

def flattener_sum(lst):
    return sum(lst, [])

Que parece muy simple y eficaz:

>>> lista_anidada = [0, ['a', 'b', 'c'], 1, ['A', ('aA', 'bB', 'cC'), 'B'], 2]
>>> flattener_sum(lista_anidada)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<input>", line 2, in flattener_sum
TypeError: can only concatenate list (not "int") to list
>>> lista_anidada = [['a', 'b', 'c'], ['A', ('aA', 'bB', 'cC'), 'B']]
>>> flattener_sum(lista_anidada)
['a', 'b', 'c', 'A', ('aA', 'bB', 'cC'), 'B']
>>>

Pero que como vemos tiene un problema, solo funciona con lista de un solo nivel de anidamiento y además solo funciona únicamente con listas que solo contienen otras listas.

Otro método que solo funciona un nivel de anidamiento, y solo con listas de iterables (soporta tuplas, generadores...) es el siguiente:

def flattener(lst):
    return [item for sublist in lst for item in sublist]

>>> lista_anidada = [['a', 'b', 'c'], (i for i in range(12))]
>>> flattener(lista_anidada)
['a', 'b', 'c', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>>

Pero las listas anidadas compuestas únicamente de otros iterables son un caso demasiado concreto y probablemente poco frecuente. Vamos a ver ahora cuatro métodos que funcionan en todos los casos, en todo tipo de listas anidadas y a cualquier nivel de anidamiento.

Aplanar cualquier tipo de lista anidada.

El primer ejemplo que pongo aquí se deriva del primero en que empleábamos la función sum() y que realizó Chema Cortés en esta pregunta de majibu.

def flat_sum(lst):
    return sum((flat_sum(elem) if
                hasattr(elem, "__iter__") and not isinstance(elem, basestring)
                else [elem] for elem in lst), [])

Y que como podemos ver, ya puede aplanar sin problemas el primer ejemplo que poníamos:

>>> lista_anidada = [0, ['a', 'b', 'c'], 1, ['A', ('aA', 'bB', 'cC'), 'B'], 2]
>>> flat_sum(lista_anidada)
[0, 'a', 'b', 'c', 1, 'A', 'aA', 'bB', 'cC', 'B', 2]

Este método es relativamente fácil de recordar, pero tiene un rendimiento muy pobre, como ya veremos más adelante.

El siguiente método lo encontré en esta pregunta de StackOverflow, y obtiene la mejor puntuación de todas las soluciones propuestas. Seguramente se debe a lo elegante de la solución y a que los generadores tienen fama de eficaces y de consumir poco espacio en RAM. Aunque como luego veremos, es quizá la peor de las soluciones que aquí comento.

def flat_yield(lst):
    def flatten(lst):
        for elm in lst:
            if hasattr(elm, "__iter__") and not isinstance(elm, basestring):
                for sub in flatten(elm):
                    yield sub
            else:
                yield elm

    return list(flatten(lst))

Aunque en la función original esta línea:

if hasattr(elm, "__iter__") and not isinstance(elm, basestring):

es sustuida por esta otra:

if (isinstance(elem, collections.Iterable) and not isinstance(elem, basestring)):

el resultado es el mismo. Aunque la solución que yo propongo es ligeramente más rápida.

Esta otra solución la hallé aquí y es un método que ya ofrece un rendimiento aceptable a la par de ser muy elegante y pythonica. Esta emplea los métodos propios de la listas append() y expand() para conseguir su objetivo. Es una función recursiva al igual que la anterior.

def flat_list(lst):
    result = []
    for elem in lst:
        if hasattr(elem, "__iter__") and not isinstance(elem, basestring):
            result.extend(flat_list(elem))
        else:
            result.append(elem)
    return result

El problema de la recursividad.

El problema de los dos métodos anteriores es que emplean recursividad, y no digo que la recursividad sea un problema, el problema son los limites por defecto en Python. Por defecto Python solo admite 1000 niveles de recursividad (e.g. una lista con 1000 niveles de anidamiento), y a nada que nuestra función supere estos niveles, nos encontraremos con un bonito error como este:

>>> RuntimeError: maximum recursion depth exceeded while calling a Python object

Aunque esto es algo que puede sortearse y podemos ampliar el limite de recursión de esta forma:

>>>import sys
>>> sys.setrecursionlimit(200000)
>>> # ahora comprobamos el nuevo limite de recursividad
>>> sys.getrecursionlimit()
200000

Ahora ya podríamos emplear el método hasta que alcanzáramos los 20.000 niveles de recursión. Aunque no me parece la manera idónea de hacer las cosas, desde luego. Si bien es cierto que será bastante difícil que nos encontremos listas anidadas hasta estos niveles en el mundo real.

La mejor solución.

Sin embargo tenemos una última solución que funciona en todos los casos y que no es recursiva y que además tiene el mejor rendimiento, con diferencia, de todos los aquí comentados. Este se basa en la sustitución en línea de los elementos de la lista empleando la operación slice Esta solución fue aportada por Chema Cortés en la misma pregunta de majibu.

def flat_slice(lst):
    lst = list(lst)
    for i, _ in enumerate(lst):
        while (hasattr(lst[i], "__iter__") and not isinstance(lst[i], basestring)):
            lst[i:i + 1] = lst[i]
    return lst

Pruebas de rendimiento

Para poder comprobar las diferencias de rendimiento entre unos métodos y otros, he preparado unos tests que ejecutan cada una de las funciones analizadas 10 veces por cada caso planteado. Las funciones que he analizado son las cuatro que soportan cualquier tipo de lista. Al final se generan unas gráficas y unos archivos en formato csv con los resultados de las pruebas. Para ello se generan un par de valores (caso) en función del número de elementos de la lista y los niveles de anidamiento de la misma. A partir de ahí planteo tres supuestos:

Número de elementos en aumento, número de niveles constante.
Número de elementos constante, número de niveles en aumento.
Número de elementos en aumento, número de niveles en aumento.

Para poder realizar estas pruebas, tenía que generar una lista que cumpliera las condiciones planteadas para cada caso. Para ello he creado una función que genera una lista anidada con el número de elementos y niveles que nosotros le indiquemos. Los elementos que la componen son números y cadenas (o solo números) organizados aleatoriamente aunque con una estructura que es constante a cualquier nivel de anidamiento o número de elementos. La razón de esto es que aunque las listas se generen de forma aleatoria, si la estructura de las mismas fuera dispar, estaríamos introduciendo un tercer factor, cuando lo que queremos medir es el rendimiento en función de dos: nº elementos y nº niveles. De esta manera podemos medir de una manera bastante fiable el rendimiento de los distintos métodos en función de estos dos factores. Aunque aún existe otro factor que podemos controlar solo hasta cierto punto, que son los procesos corriendo simultáneamente y en segundo plano en nuestra maquina. Aunque los reduzcamos al mínimo, los pocos que queden pueden generar pequeños "artefactos" que desvirtúan un poco nuestra medida, pero que para el objetivo que perseguimos podemos considerar como despreciables. La estructura de estas listas generadas es el de una lista de listas anidadas en la que se agrupan todos los elementos posibles hasta el último nivel de anidamiento solicitado. Los elementos que sobran se añaden al nivel base de la lista. Es algo así como si en el mundo real tuviéramos un campo lleno de zigurats (pirámides escalonadas de piedra) con las piedras sobrantes desperdigadas por el mismo. De ahí el nombre que le he puesto a la función.

def ziggurat(stones=1, steps=1, with_iters=False, only_numbers=False):
    """Make a list of nested lists, like a field of ziggurats."""
    # First, generate the list of the stones (numbers and "strings")
    as_str = [] if only_numbers else random.sample(range(stones), stones / 2)
    stones_list = [str(stn) if stn in as_str else stn for stn in range(stones)]
    # Find the number of step pyramids (aka ziggurats)
    num_zggts = stones / (steps + (steps - 1))
    ziggurats = []
    for zggt in range(num_zggts):
        zggt_step = []
        # Build a step pyramid, step by step, until the chosen level
        for step in range(steps):
            # Get a choice of stones from the list to make a step & remove them
            choice = random.sample(stones_list, 1 if not step else 2)
            for choosen in choice:
                stones_list.remove(choosen)
            # Build a step
            if not step:
                zggt_step.append(choice[0])
            else:
                choice.insert(1, iter(zggt_step) if with_iters else zggt_step)
                zggt_step = choice
        ziggurats.append(zggt_step)
    # IF don't have stones enough to make even a ziggurat, then will make
    # multiple one-stone-many-airsteps ziggurats
    if not num_zggts:
        for step in range(steps):
            for stn in range(0, stones, 2):
                stones_list[stn] = stones_list[stn:stn + 1]
    # Finally, mix the remaining stones and the ziggurats, et Voila!!!
    stones_list += ziggurats
    random.shuffle(stones_list)
    return stones_list

Ejemplos de listas generadas por esta función:

>>> final.ziggurat(15, 4)
[['7', ['14', [12, ['13'], '10'], 5], '11'], 1, ['2', ['0', [4, [8], 3], 9], 6]]
>>> final.ziggurat(8, 5)
[5, [[[[['2']]]]], '1', [[[[[4]]]]], [[[[['6']]]]], 3, [[[[['0']]]]], 7]
>>> final.ziggurat(8, 3, True)
[['2', ['7', [<listiterator object at 0x9fe47ac>], '5'], 1], 0, 6, 4]
>>> final.ziggurat(8, 3, only_numbers=True)
[[7, [3], 1], [2, [5], 8], [4, [0], 6]]

Una vez ejecutados estos test, podemos ver en estas gráficas los resultados de los mismos:

Analizemos gráfica a gráfica:

Aquí podemos ver que tal y como adelantaba anteriormente, la función flat_slice() es la más eficaz y la función flat_sum() la peor de todas. Además como podemos ver el incremento es constante, pero de magnitudes muy diferentes. Bueno, la verdad es que una diferencia de unos 2,25 ms por ejecución cuando la lista consta de 1400 elementos es insignificante, el hecho es que puede ser importante si se busca el rendimiento y se aplanan listas de forma masiva. En este caso no se ven afectado por el limite de recursión, todos los metodos han seguido funcionando sin problemas incluso cuando he aumentado a 10.000 elementos por lista.
En esta progresión podemos ver que las diferencias de rendimiento entre el peor método y el mejor son aún más acusadas. Curiosamente el método empleando generadores (flat_yield()) y el metodo que emplea los métodos de las listas (flat_list()) tienen un rendimiento identico. Aquí aparece por vez primer el limite de recursividad por defecto de python. Evidentemente la primera en caer es la función flat_sum(), ya que emplea doble recursividad y deja de funcionar a los 500 niveles de anidamiento por lista. Despues se caen sin remedio las funciones flat_yield() y flat_list() al alcanzar los 1000 niveles. La función flat_slice() al no ser recursiva no se ve afectada por este limite.
Finalmente en esta gŕafica despejamos todas las dudas. Al aumentar simultaneamente y en la misma proporción el número de elementos y el número de niveles, podemos ver como la función flat_yield() aumenta de manera drástica el tiempo empleado en cada ejecución. Antes de caer debido al limite de la recursividad, tenemos una diferencia de 119,38 ms por cada ejecución para 1980 elementos y 990 niveles con la función flat_slice(). Una diferencia de más de un segundo para diez ejecuciones. Y aunque esta gran diferencia desvirtua un poco la comparación entre el resto de funciones, básicamente siguen un comportamiento similar a la de la anterior gráfica, destacando otra vez el metodo flat_slice como el más eficaz de todos ellos.

Como conclusión podriamos decir que moviendonos en los valores que nos movemos, en ms, y con listas anidadas "normales" (sin llegar a cifras tan elevadas en elementos/niveles), que cualquier metodo a priori nos sirve. Aunque yo descartaría directamente el método de la función flat_sum() y apostaría por emplear siempre flat_slice(), sobre todo si va a ser ejecutado numerosas veces.

Estas funciones, alguna más, ejemplos de uso y los test de rendimento se encuentran en el fichero flatten_nested_lists.py de mi repositorio.

Comentarios realizados anteriormente en Drupal

Interesante artículo.

por kikocorreoso el Jue, 02/06/2011 - 10:53

Interesante artículo.

Por cierto, ¡Qué gráficas más chulas! ;-D

Si, la librería matplotlib da

por joe di castro el Jue, 02/06/2011 - 11:03

Si, la librería matplotlib da unos resultados muy buenos :)

Gracias por la recomendación.

¡Buen trabajo!

por Chema Cortés el Vie, 03/06/2011 - 21:28

¡Buen trabajo!

Se me hace raro que las gráficas salgan tan lineales. Esperaba que los rendimientos se degradaran al aumentar niveles y elementos.

Que la soluciones flat_list y flat_yield vayan tan parejas me da que es porque esta última está utilizando al final el constructor list() para generar la lista; pero que vaya tan mal cuando se incrementa el número de elementos y de niveles, tiene que ser debido a la sobrecarga de clausuras que hace falta mantener.

Creo que habría una opción más eficiente para reducir las clausuras. ¿Podrías hacer la prueba con esta versión de flat_yield? Gasta más memoria, pero tiene que acercarse más a flat_list. Sólo he cambiado que la recursividad se haga sobre el nivel superior en lugar de hacerlo dentro de la clausura. Ésto, en la práctica, va creando listas intermedias que sustituyen las clausuras, lo que debería simplificar el número de "contextos" a mantener:

def flat_yield(lst):
    def flatten(lst):
        for elm in lst:
            if hasattr(elm, "__iter__") and not isinstance(elm, basestring):
                for sub in flat_yield(elm):
                    yield sub
            else:
                yield elm

    return list(flatten(lst))

Gracias. Si, la verdad es que yo

por joe di castro el Vie, 03/06/2011 - 23:16

Gracias. Si, la verdad es que yo tampoco esperaba una respuesta tan lineal en los resultados, pero engañan algo, como ya comentaba, la espectacular degradación en el rendimiento de la función flat_yield, enmascara el comportamiento del resto de funciones en el último supuesto. He realizado una comparativa con todas las funciones sin emplear flat_yield, y como ves la cosa cambia ligeramente y ya se parece algo más a lo esperado, aunque siguen siendo bastante lineales.

Si, el utilizar el constructor list, cambia bastante las cosas, de hecho el método de la función flat_yield es el más rápido de todos si dejamos que devuelva solo el generador, es el crear la lista lo que lo ralentiza. Si fuéramos a emplear el resultado de la función como un iterable (en un bucle for por ejemplo), desde luego creo que sería una de las mejores soluciones (en el primer supuesto, en el resto, la recursividad sigue pesando demasiado), porque nos ahorraríamos el proceso de creación de la lista.

He realizado la prueba que me comentas con la función que me propones, la he llamado flat_yield_cc, cc por Chema Cortés :)

Creo que los resultados te chocarán un poco, no solo tiene peor rendimiento, si no que se aumenta el nivel de recursividad y se cae a los 340 niveles de anidamiento. Aunque en el tercer supuesto el rendimiento es idéntico a la función anterior, en los demás supuestos tiene el peor comportamiento de las cinco. Creo que se debe a que de esta manera, generamos aún más recursividad, una función recursiva que llama a otra que también es recursiva (después de la primera llamada a flat_yield desde flatten), lo que hace que se multipliquen los niveles de anidamiento como se ve en la gráfica.

He hecho algunas rectificaciones, las horas intempestivas a las que realice los comentarios, parece que me pesaban demasiado :-)

Fíjate en lo que ocurre

por joe di castro el Sáb, 04/06/2011 - 00:56

Fíjate en lo que ocurre cuando empleo iterables dentro de las listas anidadas generadas:

Se pueden observar dos cosas:

Lo primero que se puede ver es que el aumentar el número de elementos no supone una penalización tan grande en el tiempo empleado, gracias al empleo de iterables. De hecho, vemos que en el tercer supuesto, los tiempos son diez veces menores, lo que confirma una vez más la eficacia de los iterables al iterarlos (valga la redundancia).
Lo segundo es que la función flat_slice (aunque apenas se distingue) tiene idéntico rendimiento que flat_yield, aunque sigue siendo la más eficaz en los otros supuestos. Yo diría que esto confirma lo que comentábamos, de que es precisamente la creación de la lista en flat_yield lo que penaliza su rendimiento, ya que la función flat_slice también la crea en el primer paso, y ahora al incluir iterables en la lista anidada, su rendimiento se ve perjudicado, aunque no en la misma medida que flat_yield al no ser recursiva (razón por la cual en el incremento en los niveles de anidamiento este hecho no la perjudica tanto, es decir la recursividad tiene una penalización varias magnitudes mayor que la creación de la lista).

Monitorizar los cambios de tamaño en un directorio

2011-05-17T21:52:00+02:00

Cuando administramos varias maquinas UN*X nos puede interesar el tener controlados los cambios de tamaño en algunos directorios determinados, para poder observar pautas de comportamiento o ver cambios inesperados, para solucionar los problemas cuando o antes de que se produzcan. Y aunque hay varias formas de realizar esto, incluso con demonios que monitorizan los cambios en tiempo real (incrond, inotify, dnotify, gamin, watch, ...), puede que una solución más sencilla nos sea suficiente para directorios no críticos. Para instalaciones no complejas nos puede servir, por ejemplo, para no tener que lidiar con las quotas de disco (no siempre es una buena opción). O para evitar que por ejemplo una mala configuración en la rotación de los logs de una maquina acaben agotando el espacio disponible para la partición de sistema (caso real que me he encontrado más de una vez).

Para poder monitorizar los cambios de tamaño de un directorio (y subdirectorios) he creado un sencillo script Python que registra los cambios en la ruta que le proporcionemos y luego envía un informe por correo al buzón del usuario local. Los datos de los directorios los registra en un fichero oculto (su nombre empieza por un .) binario de tipo pickle y el informe se guarda a su vez en un archivo de texto con el mismo nombre que el script, pero terminado en .log.

El informe que genera nos muestra por un lado tantos los nuevos directorios, como los directorios que se han eliminado con la cifra del espacio en disco que ocupan (o liberan). Por otro lado también nos informa de los directorios que han cambiado de tamaño, mostrándonos en que porcentaje se han incrementado/decrementado y la cantidad de espacio que ha variado. Aquí podemos ver un ejemplo de uno de estos informes.

SCRIPT =========================================================================
dir_size_monitor (ver. 0.2)
http://code.joedicastro.com/python-recipes

Changes in size of directories for .. on yourmachine
================================================================================

START TIME =====================================================================
                                                      Tuesday 05/17/11, 21:10:48
================================================================================

NEW DIRECTORIES ________________________________________________________________

   799.72 KiB   ./src/test/bibendum
     1.14 MiB   ./src/test/condimentum
     2.31 MiB   ./src/test/laoreet
   204.28 KiB   ./src/test/risus
     2.90 MiB   ./src/test/torquent

DELETED DIRECTORIES ____________________________________________________________

   383.79 KiB   ./src/test/adipiscing
     5.38 MiB   ./src/test/consequat
   847.72 KiB   ./src/test/etiam
   938.93 KiB   ./src/test/maecenas
     3.55 MiB   ./src/test/tincidunt
     2.33 MiB   ./src/test/viverra

CHANGED DIRECTORIES ____________________________________________________________

    34.79 %     55.5 MiB   ./src
    34.82 %     55.5 MiB   ./src/test
   -99.97 %     15.3 MiB   ./src/test/odio
   -99.97 %     15.6 MiB   ./src/test/tellus

THRESHOLD VALUES _______________________________________________________________

The directories whose size differences are less than any of these values are ignored:

Percentage:     10 %
Size:        10.00 MiB

.. STATISTICS __________________________________________________________________

      78 directories
  215.04 MiB

END TIME =======================================================================
                                                      Tuesday 05/17/11, 21:10:48
================================================================================

Opcionalmente podemos establecer dos valores de umbral para que se ignoren todos los cambios que estén por debajo de estas dos cifras. Para desactivarlos simplemente hay que dejarlos a cero. Estas cifras se refieren por un lado al porcentaje de diferencia mínimo que deseamos establecer para que se nos informe y por otro a la cantidad mínima (expresada en bytes) de espacio en disco que se ha incrementado/decrementado en ese directorio. Pueden funcionar los dos a la vez, por lo que se han de cumplir las dos condiciones, o solamente uno dejando el otro a cero.

Si programamos este script para que se ejecute cada cierto tiempo, podemos tener una idea aproximada de los cambios producidos en el. Y digo aproximada porque este nos muestra únicamente los cambios registrados entre dos instantáneas tomadas, una en la ejecución anterior y otra en la ejecución actual. Y por lo tanto no esperemos obtener la relación de todos los cambios producidas entre ellas. Para conocer algo a ese nivel de detalle es mejor emplear uno de los servicios en tiempo real que mencionaba al principio. Dicho esto, es evidente que en la primera ejecución no tiene sentido informar de nada y de hecho hasta la segunda ejecución no empezara a generar informes.

Este es el contenido de dir_size_monitor.py es el siguiente:

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    dir_size_monitor.py: Monitors changes in the size of dirs for a given path
"""

#===============================================================================
# This Script monitors the changes in disk size for the directories included in
# a given path. It reports what directories are new or deleted. Also reports the
# directories in which their size increases or decreases above threshold values.
# These threshold values refer to the amount in difference of size of the 
# directory or/and the percentage difference. These values can be overrided by 
# setting them to zero.
#
# The final report is sended via email to the local user. This script is 
# intended to run periodically (e.g. via cron) 
#===============================================================================

#===============================================================================
#    Copyright 2011 joe di castro <joe@joedicastro.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#===============================================================================

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "17/05/2011"
__version__ = "0.2"

try:
    import sys
    import os
    import platform
    import pickle
    import logger
    from get_size import best_unit_size, get_size_fast
except ImportError:
    # Checks the installation of the necessary python modules 
    print((os.linesep * 2).join(["An error found importing one module:",
    str(sys.exc_info()[1]), "You need to install it", "Stopping..."]))
    sys.exit(-2)

def list4log(dirs_size_dict, wpath, dirs):
    """Create a list of new or deleted directories for the log."""
    llst = []
    for ldir in sorted(dirs):
        dsz = best_unit_size(dirs_size_dict[ldir])
        llst.append(" {0:8.2f} {1}   ./{2}".
                    format(dsz['s'], dsz['u'], os.path.relpath(ldir, wpath)))
    return llst

def diff4log(before, current, wpath, dirs, threshold_pct=0, threshold_sz=0):
    """Create a list of the directories that had size changes for the log."""
    llst = []
    for ddir in sorted(dirs):
        pct = (((current[ddir] - float(before[ddir])) / before[ddir]) * 100.0)
        diff = current[ddir] - before[ddir]
        if abs(pct) >= threshold_pct and abs(diff) > threshold_sz:
            dsz = best_unit_size(diff)
            llst.append(" {0:8.2f} % {1:8.1f} {2}   ./{3}".
                        format(pct, dsz['s'], dsz['u'], os.path.relpath(ddir,
                                                                        wpath)))
    return llst

def main(first_exec=False):
    """Main section"""
    # The path to monitor changes in directories dir_size
    mon_pth = "/your/path/to/monitor"

    # Ignore all directories that are below these percentage or absolute value 
    # of size difference. There are optional, set to zero to override them.
    thld_pct = 20      # In percentage of difference in size for a directory
    thld_sz = 10.486E6 # In bytes of absolute value of directory size difference

    # Prepare the log
    log = logger.Logger()
    url = "http://code.joedicastro.com/python-recipes"
    head = ("Changes in size of directories for {0} on {1}".
            format(mon_pth, platform.node()))
    log.header(url, head)
    log.time("START TIME")

    # Load the last dictionary of directories/sizes if exists
    try:
        with open('.dir_sizes.pkl', 'rb') as input_file:
            bfr_dir = pickle.load(input_file)
    except (EOFError, IOError, pickle.PickleError):
        bfr_dir = {}
        first_exec = True

    # Get the current dictionary of directories/sizes
    crr_dir = {}
    for path, dirs, files in os.walk(mon_pth):
        for directory in dirs:
            dir_path = os.path.join(path, directory)
            dir_size = get_size_fast(dir_path)
            crr_dir[dir_path] = dir_size

    # First, Save the current dirs/sizes
    with open(".dir_sizes.pkl", "wb") as output_file:
        pickle.dump(crr_dir, output_file)

    # Create the list depending the status of directories
    deleted = [d for d in bfr_dir if d not in crr_dir]
    added = [d for d in crr_dir if d not in bfr_dir]
    changed = [d for d in crr_dir if d in bfr_dir if crr_dir[d] != bfr_dir[d]]

    log.list("Deleted directories", list4log(bfr_dir, mon_pth, deleted))
    log.list("New directories", list4log(crr_dir, mon_pth, added))
    log.list("Changed directories", diff4log(bfr_dir, crr_dir, mon_pth, changed,
                                             thld_pct, thld_sz))

    # If thresholds are nonzero, then report the values 
    if thld_pct or thld_sz:
        tsz = best_unit_size(thld_sz)
        log.list("Threshold Values",
                 ["The directories whose size differences are less than any of "
                  "these values are ignored:", "",
                  "Percentage: {0:6} %".format(thld_pct),
                  "Size:       {0:6.2f} {1}".format(tsz['s'], tsz['u'])])

    # Show some statistics for the analyzed path
    mon_pth_sz = best_unit_size(get_size_fast(mon_pth))
    log.list("{0} Statistics".format(mon_pth),
             ["{0:8} directories".format(len(crr_dir)),
              "{0:8.2f} {1}".format(mon_pth_sz['s'], mon_pth_sz['u'])])
    log.time("END TIME")
    if not first_exec:
        log.send("Changes in size of directories")
        log.write()

if __name__ == "__main__":
    main()

Este script necesita los módulos get_size y logger para poder funcionar. Solo es necesario descargar los archivos y guardarlos en el mismo directorio donde se aloje este script. La versión más actualizada de este script se puede encontrar en mi repositorio

Conocer el tamaño de un directorio con Python

2011-05-16T21:05:00+02:00

Aunque conocer el tamaño de un directorio en sistemas como Linux es algo trivial, solo es necesario emplear el comando du, si queremos hacer lo mismo con Python -sin hacer uso de este comando- la cosa ya no es tan sencilla. Sobre todo si lo que queremos es una solución que nos devuelva tanto el tamaño de un fichero como el de un directorio. Cuando me encontré con esta necesidad lo primero que hice fue buscar en Internet para conocer alguna solución previa (reinventar la rueda no siempre es lo mejor) y me encontré con esto:

def get_dir_size(the_path):
    """Get size of a directory tree in bytes."""
    path_size = 0
    for path, dirs, files in os.walk(the_path):
        for fil in files:
            filename = os.path.join(path, fil)
            path_size += os.path.getsize(filename)
    return path_size

Esta solución nos daría el tamaño en bytes de un directorio. Pero esta solución, que encontré en varios sitios, presentaba dos problemas:

No da un tamaño exacto. Esto se debe a que no tiene en cuenta las carpetas y ficheros ocultos (los que empiezan con un . en Linux) y los ficheros especiales .. (que apuntan al directorio superior). Además tampoco tiene en cuenta los enlaces simbólicos. Por está razón la salida de esta función no coincide con el espacio que nos reporta el comando UN*X du -bs
No funciona para un solo fichero. Solo trabaja cuando lo ejecutamos sobre un directorio, al hacerlo sobre un solo fichero nos dará como resultado siempre 0.

Teniendo en cuenta este punto de partida, elaboré una función que solucionara estos dos problemas y que devolviera el tamaño exacto de un directorio o fichero. Esta es la función que nos da el resultado correcto:

def get_size(the_path):
    """Get size of a directory tree or a file in bytes."""
    path_size = 0
    for path, directories, files in os.walk(the_path):
        for filename in files:
            path_size += os.lstat(os.path.join(path, filename)).st_size
        for directory in directories:
            path_size += os.lstat(os.path.join(path, directory)).st_size
    path_size += os.path.getsize(the_path)
    return path_size

El resultado de esta función es el mismo que el que nos devuelve el comando Linux du -bs. Además tiene en cuenta los enlaces simbólicos y no los sigue. Luego buscando una solución ligeramente más rápida (aunque menos elegante y pythonica) y que siguiera dando resultados precisos, cree una variante basada en el empleo de generadores.

def get_size_fast(the_path):
    """Get size of a directory tree or a file in bytes."""

    def get_sizes(the_path):
        """Make a generator of individual file & directory sizes."""
        if not os.path.islink(the_path):
            if os.path.isdir(the_path):
                for file_or_dir in os.listdir(the_path):
                    path = os.path.join(the_path, file_or_dir)
                    if os.path.isfile(path):
                        yield os.lstat(path).st_size
                    else:
                        for size in get_sizes(path):
                            yield size
            yield os.lstat(the_path).st_size
        else:
            yield os.lstat(the_path).st_size

    return sum(get_sizes(the_path))

Obtener el tamaño del directorio en la mejor unidad posible

Estas funciones proporcionan el resultado que deseamos, pero lo entregan en una unidad difícilmente legible, en bytes. ¿Que ocurre si queremos verlo en Mebibytes, GibiBytes, ... y que además sea siempre la más adecuada para una mejor visualización? Para responder a esta pregunta desarrolle una función que nos hace precisamente esto, tomar un tamaño en bytes y devolvernos el valor correcto en la unidad binaria IEC más adecuada:

def best_unit_size(bytes_size):
    """Get a size in bytes & convert it to the best IEC prefix for readability.

    Return a dictionary with three pair of keys/values:

    "s" -- (float) Size of path converted to the best unit for easy read
    "u" -- (str) The prefix (IEC) for s (from bytes(2^0) to YiB(2^80))
    "b" -- (int / long) The original size in bytes

    """
    for exp in range(0, 90 , 10):
        bu_size = abs(bytes_size) / pow(2.0, exp)
        if int(bu_size) < 2 ** 10:
            unit = {0:"bytes", 10:"KiB", 20:"MiB", 30:"GiB", 40:"TiB", 50:"PiB",
                    60:"EiB", 70:"ZiB", 80:"YiB"}[exp]
            break
    return {"s":bu_size, "u":unit, "b":bytes_size}

Esta función nos devuelve un diccionario con tres claves:

's': Es el tamaño convertido a la mejor unidad IEC posible en términos de legibilidad.
'u': Es el prefijo IEC para el tamaño anterior.
'b': Es el tamaño original en bytes.

Para entenderla, lo mejor es mostrar algunos ejemplos:

>>> import get_size
>>> size = get_size.best_unit_size(38467206502)
>>> "{0:.2f} {1}".format(size['s'], size['u'])
'35.83 GiB'
>>> size = get_size.best_unit_size(45332)
>>> "{0:.2f} {1}".format(size['s'], size['u'])
'44.27 KiB'
>>> size = get_size.best_unit_size(9878323)
>>> "{0:.2f} {1} es igual a {2} bytes".format(size['s'], size['u'], size['b'])
'9.42 MiB es igual a 9878323 bytes'

Y evidentemente, combinar las dos funciones en una, nos evita tener que pasar las dos a un mismo directorio/fichero.

def get_unit_size(the_path):
    """Calculate size of a directory/file & convert it for the best IEC prefix.

    Return a dictionary with three pair of keys/values:

    "s" -- (float) Size of path converted to the best unit for easy read
    "u" -- (str) The prefix (IEC) for s (from bytes(2^0) to YiB(2^80))
    "b" -- (int / long) The original size in bytes

    """

    bytes_size = 0
    for path, directories, files in os.walk(the_path):
        for filename in files:
            bytes_size += os.lstat(os.path.join(path, filename)).st_size
        for directory in directories:
            bytes_size += os.lstat(os.path.join(path, directory)).st_size
    bytes_size += os.path.getsize(the_path)

    for exp in range(0, 90 , 10):
        bu_size = abs(bytes_size) / pow(2.0, exp)
        if int(bu_size) < 2 ** 10:
            unit = {0:"bytes", 10:"KiB", 20:"MiB", 30:"GiB", 40:"TiB", 50:"PiB",
                    60:"EiB", 70:"ZiB", 80:"YiB"}[exp]
            break
    return {"s":bu_size, "u":unit, "b":bytes_size}

Que nos devuelve un diccionario similar al anterior, lo que nos proporciona la posibilidad de disponer tanto del tamaño en bytes como en la mejor unidad IEC posible con una única función.

Todas estas funciones con ejemplos (y además una clase que hace uso de ellas), se pueden encontrar en el fichero get_size.py de mi repositorio. Si se ejecuta el fichero como un script puede verse una comparativa de las diversas funciones en rendimiento y precisión con respecto al comando du -bs

Enviar un correo electrónico con Python

2011-05-08T13:29:00+02:00

Existen varias maneras de enviar un correo electrónico a través de Python, por ejemplo empleando el modulo smtplib de la librería estándar de Python. Si estamos en Linux y contamos con un servidor de correo funcionando, enviar un correo puede ser algo tan sencillo como este script:

#!/usr/bin/env python
# -*- coding: utf8 -*-

import os
import socket
import smtplib

def send_mail_local(subject, text):
    """Send a mail to the user's local mailbox."""
    # Set the local mail address for the script' user
    email = "@".join([os.getenv("LOGNAME"), socket.gethostname()])
    msg = ("From: {0}\nTo: {0}\nSubject: {1}\n{2}".format(email, subject, text))
    server = smtplib.SMTP("localhost")
    server.sendmail(email, email, msg)
    server.quit()
    return

def main():
    """Main section"""

    send_mail_local("Comprobando el envío de correo localmente",
                    "Si puedes leer esto, tu servidor local SMTP está OK")

    print("Comprueba el correo en tu buzón local {0}\nEste normalmente se "
          "encuentra situado en /var/mail/{1}".
          format("@".join([os.getenv("LOGNAME"), socket.gethostname()]),
                 os.getenv("LOGNAME")))

if __name__ == "__main__":
    main()

Que si lo ejecutamos, nos generará una salida por consola como esta:

Comprueba el correo en tu buzón local tuusuario@tumaquina
Este normalmente se encuentra situado en /var/mail/tuusuario

Y tendrás en la bandeja de correo de tu usuario en la maquina algo como esto:

De:     tuusuario@tumaquina
Para:   tuusuario@tumaquina
Asunto:     Comprobando el envío de correo localmente
Fecha:  Sun, 08 May 2011 12:57:30 +0200

Si puedes leer esto, tu servidor local SMTP está OK

Es algo realmente sencillo, y la mayoría de las lineas sirven para construir el ejemplo, lo que realmente hace el trabajo, y solo necesita el modulo smtplib para funcionar es esto:

server = smtplib.SMTP("localhost")
server.sendmail(email, email, msg)
server.quit()

Pero si lo que queremos es enviar correos más complejos, con adjuntos, empleando servidores SMTP externos y enviar con copia (CC) ó copia oculta (CCO) a varios usuarios, entonces ya necesitamos emplear las opciones del modulo email que nos permite hacer prácticamente cualquier tarea relacionada con los correos electronicos. Para estas situaciones desarrolle en su día una función que ha cubierto todas las situaciones que se me han dado hasta ahora. Además devuelve mensajes de error allí donde algo puede ir mal.

# The more complete solution. This adds the Cc: (Carbon Copy) and Bcc: (Blind 
# Carbon Copy) fields and the ability to add attachments. 
def send_email(subject, text, send_from="", dest_to=None, attachments=None,
               send_cc=None, send_bcc=None, server="localhost", port=25,
               user="", passwd=""):
    """Send a email with(out) attachment(s) enabling CC and BCC fields.

    Arguments:
        (str) subject -- the mail's subject
        (str) text -- the message's text
        (str) send_from -- a sender's email address (default "")
        (list) dest_to -- a list of receivers' email addresses ("")
        (list) attachments -- a list of attachments files (default None)
        (list) send_cc -- a list of carbon copy's email addresses (def. None)
        (list) send_bcc -- a list of blind carbon copy's email addresses (None)
        (str) server -- the smtp server (default "localhost")
        (int) port -- the smtp server port (default 25)
        (str) user -- the smtp server user (default "")
        (str) passwd --the smtp server password (default "")

    If "send_from" or "dest_to" are empty or None, then script user's mailbox 
    is assumed instead. Useful for logging scripts

    """
    local_email = "@".join([os.getenv("LOGNAME"), socket.gethostname()])
    send_from = send_from if send_from else local_email
    dest_to = dest_to if dest_to else [local_email]

    dest_to_addrs = dest_to # receivers mails including to, cc and bcc fields
    message = MIMEMultipart()
    message["Subject"] = subject
    message["From"] = send_from
    message["To"] = COMMASPACE.join(dest_to)
    if send_cc:
        message["Cc"] = COMMASPACE.join(send_cc)
        dest_to_addrs += send_cc
    if send_bcc:
        dest_to_addrs += send_bcc
    message["Date"] = formatdate(localtime=True)
    message.preamble = "You'll not see this in a MIME-aware mail reader.\n"
    message.attach(MIMEText(text))

    # For all type of attachments
    if attachments:
        for att_file in attachments:
            with open(att_file, "rb") as attmnt:
                att = MIMEBase("application", "octet-stream")
                att.set_payload(attmnt.read())
            encoders.encode_base64(att)
            att.add_header("content-disposition", "attachment",
                           filename=os.path.basename(att_file))
            message.attach(att)

    # initialize the mail server
    smtp_server = smtplib.SMTP()
    # Connect to mail server
    try:
        smtp_server.connect(server, port)
    except socket.gaierror:
        print("mail error", "Wrong server, are you sure is correct?")
    except socket.error:
        print("mail error", "Server unavailable or connection refused")
    # Login in mail server
    if server != "localhost":
        try:
            smtp_server.login(user, passwd)
        except smtplib.SMTPAuthenticationError:
            print("mail error", "Authentication error")
        except smtplib.SMTPException:
            print("mail error", "No suitable authentication method")
    # Send mail
    try:
        smtp_server.sendmail(send_from, dest_to_addrs, message.as_string())
    except smtplib.SMTPRecipientsRefused:
        print("mail error", "All recipients were refused."
              "Nobody got the mail.")
    except smtplib.SMTPSenderRefused:
        print("mail error", "The server didn’t accept the from_addr")
    except smtplib.SMTPDataError:
        print("mail error", "An unexpected error code, Data refused")
    # Disconnect from server
    smtp_server.quit()

Para las situaciones en las que no disponemos de un servidor de correo SMTP funcionando, podemos montar uno temporalmente para realizar pruebas. La tarea puede tan sencilla como recurrir a uno de los python one-liners que mencionaba en Python one-liners. Potencia en una sola línea.

python -m smtpd -n -c DebuggingServer localhost:8025

que es exactamente lo mismo que hace este script que empleo habitualmente para las mismas funciones (me permite montar un segundo servidor SMTP en un puerto distinto sin necesitar permisos de administrador, lo que me permite llamarlo desde otros scripts). Emplear una u otra forma, pues ya depende de uno.

#!/usr/bin/env python
# -*- coding: utf8 -*-

import smtpd
import asyncore

def smtp_server(port):
    """Starts a smtp server for test purposes."""
    smtpd.DebuggingServer(("localhost", port), None)

smtp_server(8025)
try:
    asyncore.loop()
except KeyboardInterrupt:
    pass

El código completo con ejemplos de estas funciones, se puede encontrar en mi repositorio.

Logger, informes legibles para tus scripts Python

2011-05-07T23:02:00+02:00

Normalmente los scripts que se crean para ser ejecutados periódicamente, como los de administración de sistemas, realizan tareas que generan cambios que queremos conocer. Esta información se suele guardar en logs o se envía por correo a una dirección de email. Hay muchas formas de generar estos logs, pero normalmente es una simple salida de texto plano en consola, que no suele tener una presentación muy "amigable" o legible. Cuando tienes una cantidad generosa de estos scripts, los recibes por correo electrónico y con una frecuencia diaria o mayor, lo que menos deseas es andar buscando la información entre lineas de texto plano. Lo que yo quiero es poder identificar la información rápidamente de un vistazo, además tenía una idea rondando por la cabeza, que seria aún más cómodo si todos emplearan un formato similar. Con estas premisas cree un módulo Python, logger.py, que empleo en muchos de mis scripts en Python y que me permite analizar adecuadamente la información que me interesa.

Un ejemplo de informe generado por este modulo Python sería el siguiente (el mismo que se generaría si ejecutáramos el modulo como script):

SCRIPT =========================================================================
logger (ver. 0.3)
http://code.joedicastro.com/python-recipes

This is a test of class Logger
================================================================================

START TIME =====================================================================
                                                     Saturday 05/07/11, 21:51:27
================================================================================

BLOCK ==========================================================================
This
is
a
sample
of
Logger.block()
================================================================================

LIST ___________________________________________________________________________

This
is
a
sample
of
Logger.list()

This a sample of logger.free() text.

"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque sed
tortor eget justo vehicula consequat vel eu quam. Suspendisse non lectus eget
orci varius adipiscing."

END TIME =======================================================================
                                                     Saturday 05/07/11, 21:51:27
================================================================================

Este modulo contiene una clase, Logger(), que dispone de una serie de métodos que nos permiten diversas tareas, supongamos que tenemos un objeto log de la clase Logger():

log.header(url, msg)

Nos crea una cabecera para el script que nos aporta cierta información que nos sirve para identificar el mismo y el contexto en el que se ejecuta.

SCRIPT =========================================================================
nombre del script (versión)
http://miweb.com/script

mensaje que nos informa de la finalidad del mismo o de 
información dependiente del contexto. Totalmente 
personalizable.
================================================================================

log.time(title)

Nos permite registrar el tiempo de un evento. Normalmente lo empleo para registrar el comienzo y el final de la ejecución del script.

TITULO =========================================================================
                                                       Sábado 07/05/11, 22:18:27
================================================================================

log.block(title, content)

Crea un bloque de texto con titulo y enmarcado por líneas compuestas por el carácter =. Entre esas lineas y el contenido no hay ninguna linea en blanco. Es útil para destacar cierto contenido del resto de forma muy notable, suelo utilizarlo para ubicar el script en su contexto.
```
TITULO =========================================================================
contenido
sigue el contenido
...
================================================================================
```
log.list(title, content)

Como su nombre bien indica, es una lista de líneas con un simple encabezado que lo distinga del resto. Suelo emplearlo para volcar la información generada por el script. Entre el encabezado y la primera línea de texto existe una línea en blanco.
```
TITULO __________________________________________________

Primera línea del contenido
Segunda línea del contenido
...
```
log.free(content)

Texto libre, párrafos que se mostrarán tal y como son, sin formato ni cabecera alguna. Raramente lo empleo, pero es útil por ejemplo para introducir comentarios, licencias, etc.
log.send(subject, send_from='', dest_to='', mail_server='localhost', server_user='', server_pass='')

El meollo del script. Se emplea para mandar el resultado por correo electrónico. Si solo especificamos el asunto, empleará nuestro servidor de correo local para mandar el informe al buzón local del usuario que programó/ejecuto el script. Pero se pueden especificar tanto el empleo de un servidor de correo (SMTP) distinto como otro (o varios) destinatario(s) en particular.
log.write(append=False)

Escribe el resultado del log en un fichero de texto. El nombre de este fichero estará compuesto por el nombre del script sin extensión, más la extensión .log. Si append es True entonces añadirá el resultado al final de texto, si no, lo reescribirá en cada ejecución guardando únicamente el último informe.
log.get()

Nos devuelve el contenido del log. Es útil cuando estamos con tareas de depurado, con un print llamando a este método podemos volcar en la consola la información registrada en el log.

El código del script es el siguiente:

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    logger.py: Create a log object to log script messages in a elegant way
"""

#===============================================================================
# This module create a log object to log script messages in a elegant way
#===============================================================================

#===============================================================================
#    Copyright 2010 joe di castro <joe@joedicastro.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#===============================================================================

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "10/09/2010"
__version__ = "0.3"

try:
    import sys
    import os
    import time
    import smtplib
    import socket
    from email.mime.text import MIMEText
    from email.mime.multipart import MIMEMultipart
    from email.utils import COMMASPACE, formatdate
except ImportError:
    # Checks the installation of the necessary python modules 
    print((os.linesep * 2).join(["An error found importing one module:",
    str(sys.exc_info()[1]), "You need to install it", "Stopping..."]))
    sys.exit(-2)

class Logger():
    """

    Create a log object to log script messages.

    These messages can be sended via email or writed in a log file

    """

    def __init__(self):
        """Create the object Logger itself and set various attributes.

        These attributes are about the python file wich invokes this module:

        __script_vers = The version of python file which invokes this module
        __script_name = The name of the python file which invokes this module
        filename = the log file's name

        """
        from __main__ import __dict__ as __dict
        self.__log = ''
        if '__version__' in __dict.keys():
            self.__script_vers = __dict['__version__']
        else:
            self.__script_vers = 'Unknown'
        self.__script_name = os.path.basename(__dict['__file__']).split('.')[0]
        self.filename = '{0}.log'.format(self.__script_name)

    def __len__(self):
        return len(self.__log)

    def __format__(self, tit, cont, decor):
        """Format a block or a list of lines to enhance comprehension.

        (str) tit -- title for the block or list
        (str or iterable) cont -- line/s for the list/block content
        ('=' or '_') decor - define if it's list or block and decorate it

        make the looks of self.block() and self.list()

        """
        ending = {'=':'', '_':os.linesep}[decor]
        end = {'=': '=' * 80, '_':''}[decor]
        begin = ' '.join([tit.upper(), (80 - (len(tit) + 1)) * decor]) + ending
        cont = [cont] if isinstance(cont, str) else cont
        sep = os.linesep
        self.__log += sep.join([begin, sep.join(cont), end, sep])

    def block(self, title, content):
        """A block of text lines headed and followed by a line full of '='.

        (str) title -- The title that start the first line of '='
        (str or iterable) content -- The line/s between the '=' lines

        There's not any empty line between the '=' lines and content, e.g.:

        TITLE ==================================================
        content
        ========================================================

        """
        if content:
            self.__format__(title, content, '=')

    def list(self, title, content):
        """A list of text lines headed by a line full of '_'.

        (str) title -- The title that start the line of '_'
        (str or iterable) content -- The line/s after the '_' line

        After the '_' line is a empty line between it and the content, e.g.:

        TITLE __________________________________________________

        content

        """
        if content:
            self.__format__(title, content, '_')

    def free(self, content):
        """Free text unformatted.

        (str) content -- Text free formated

        """
        if isinstance(content, str):
            self.__log += content + os.linesep * 2

    def time(self, title):
        """A self.block() formated line with current time and date.

        (str) title -- Title for self.block()

        Looks like this, the data and time are right-justified:

        TITLE ==================================================
                                       Friday 09/10/10, 20:01:39
        ========================================================

        """
        self.block(title, '{0:>80}'.format(time.strftime('%A %x, %X')))

    def header(self, url, msg):
        """A self.block() formated header for the log info.

        (str) url -- The url of the script
        (str) msg -- Message to show into the header. To Provide any useful info

        It looks like this:

        SCRIPT =================================================
        script name and version
        url

        msg
        ========================================================

        """
        script = '{0} (ver. {1})'.format(self.__script_name, self.__script_vers)
        self.block('Script', [script, url, '', msg])

    def get(self):
        """Get the log content."""
        return self.__log

    def send(self, subject, send_from='', dest_to='', mail_server='localhost',
             server_user='', server_pass=''):
        """Send a email with the log.

        Arguments:
            (str) send_from -- a sender's email address (default '')
            (str or list) dest_to -- a list of receivers' email addresses ('')
            (str) subject -- the mail's subject
            (str) mail_server -- the smtp server (default 'localhost')
            (str) server_user -- the smtp server user (default '')
            (str) server_pass --the smtp server password (default '')

        If 'send_from' or 'dest_to' are empty or None, then script user's
        mailbox is assumed instead. Useful for loggin scripts

        """
        local_email = '@'.join([os.getenv('LOGNAME'), socket.gethostname()])
        if not send_from:
            send_from = local_email
        if not dest_to:
            dest_to = [local_email]

        dest_to_addrs = COMMASPACE.join(dest_to) # receivers mails
        message = MIMEMultipart()
        message['Subject'] = '{0} - {1}'.format(subject,
                                                time.strftime('%A %x, %X'))
        message['From'] = send_from
        message['To'] = dest_to_addrs
        message['Date'] = formatdate(localtime=True)
        message.preamble = "You'll not see this in a MIME-aware mail reader.\n"
        message.attach(MIMEText(self.__log))

        # initialize the mail server
        server = smtplib.SMTP()
        # Connect to mail server
        try:
            server.connect(mail_server)
        except socket.gaierror:
            self.list('mail error', 'Wrong server, are you sure is correct?')
        except socket.error:
            self.list('mail error', 'Server unavailable or connection refused')
        # Login in mail server
        if mail_server != 'localhost':
            try:
                server.login(server_user, server_pass)
            except smtplib.SMTPAuthenticationError:
                self.list('mail error', 'Authentication error')
            except smtplib.SMTPException:
                self.list('mail error', 'No suitable authentication method')
        # Send mail
        try:
            server.sendmail(send_from, dest_to_addrs, message.as_string())
        except smtplib.SMTPRecipientsRefused:
            self.list('mail error', 'All recipients were refused.'
                      'Nobody got the mail.')
        except smtplib.SMTPSenderRefused:
            self.list('mail error', 'The server didn’t accept the from_addr')
        except smtplib.SMTPDataError:
            self.list('mail error', 'An unexpected error code, Data refused')
        # Disconnect from server
        server.quit()

    def write(self, append=False):
        """Write the log to a file.

        The name of the file will be like this:

        script.log

        where 'script' is the name of the script file without extension (.py)

        (boolean) append -- If true appends log to file, else writes a new one

        """
        mode = 'ab' if append else 'wb'
        with open(self.filename, mode) as log_file:
            log_file.write(self.__log)

def main():
    """Main section"""
    url = 'http://code.joedicastro.com/python-recipes'
    head = 'This is a test of class Logger'

    log = Logger()
    log.header(url, head)
    log.time('Start time')
    log.block('Block', 'This is a sample of Logger.block()'.split())
    log.list('List', 'This is a sample of Logger.list()'.split())
    log.free('''This a sample of logger.free() text.

"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque sed
tortor eget justo vehicula consequat vel eu quam. Suspendisse non lectus eget
orci varius adipiscing."''')
    log.time('End time')
    log.send('This is mail test')
    log.write(True)
    log.free('All of this had been recorded in {0}'.format(log.filename))
    print(log.get())

if __name__ == "__main__":
    main()

Para acceder a la versión más reciente del mismo, acudir a mi repositorio

Ejemplos de utilización de este modulo pueden ser lftp-mirror (incluido dentro del mismo), TEDTalks, dpkg_diff y ban_drupal_spammers

Generar informes de cambios en paquetes instalados en Debian y Ubuntu.

2011-05-06T22:55:00+02:00

Una de las políticas de seguridad que tengo con mis sistemas Linux, es además de efectuar respaldos periódicos (diarios) del contenido del directorio /home (en mi caso siempre es una partición o disco independiente), es siempre guardar también una lista de los paquetes instalados en los mismos. Prácticamente nunca hago una copia completa de la partición o disco de de sistema, y aunque si hago una copia de los directorios más importantes, prefiero tener siempre una relación actualizada de los paquetes instalados en cada maquina.

En sistemas Linux Debian y otras distribuciones derivadas (Ubuntu, Mint, Mepis, Knoppix, ...) obtener esta lista es realmente sencillo, pues solo es necesario ejecutar este comando:

dpkg -l > lista_paquetes.txt

Y con eso, se generaría una lista de los paquetes instalados¹ en el sistema en el fichero lista_paquetes.txt. Y mantener actualizado este fichero es tan sencillo como programar (via crontab por ejemplo) la ejecución de este comando con un sencillo script shell. Y así lo he realizado durante años, hasta que quise tener aun más información.

Entonces me interesó conocer también los cambios que se producen en los paquetes, es decir nuevas (des)instalaciones y actualizaciones. Es lógico pensar que si uno mismo es el que las realiza, pues ya sabe esta información de primera mano. Pero la memoria es frágil y no demasiado confiable, además ¿que ocurre cuando en una misma maquina tienen permisos para administrar los paquetes más de un usuario?

Se pueden conocer estos cambios de los paquetes en el tiempo de varios modos, desde acudir a los logs de dpkg en /var/log/dpkg.log y examinarlos con algún analizador de logs (o el más sencillo e inmediato comando less) hasta consultarlos de una manera más sencilla y gráfica con el gestor de paquetes Synaptic (en el menú Archivo -> Histórico). Pero me interesaba automatizar esto, para conocer esos cambios poco después de que se produjeran y lo lógico era emplear el mismo script shell que empleaba para generar la lista de paquetes instalados. Así lo hice entonces, combinando los comandos awk, grep, diff y mail con el comando del principio para obtener la lista, tenia los cambios en mi buzón de correo al poco tiempo de producirse. Y ha funcionado perfectamente hasta ahora.

Pero desde que me introduje en el lenguaje Python, he ido migrando poco a poco los scripts bash que tengo para reescribirlos en este lenguaje. Y recientemente le ha tocado a este. Ha sido muy fácil y la verdad es que el resultado aunque funcionalmente es el mismo, me ha permitido entregar unos informes más elegantes y fáciles de interpretar de un golpe de vista.

Ahora, cuando se realiza algún cambio en los paquetes del sistema, de forma automática, por mi o por otro usuario autorizado, yo recibo en mi correo un informe similar a este:

SCRIPT =========================================================================
dpkg_diff (ver. 0.1)
http://code.joedicastro.com/python-recipes

Changes of packages installed on yourmachine
 ===============================================================================

START TIME =====================================================================
                                                     Thursday 05/05/11, 10:30:01
 ===============================================================================

INSTALLED PACKAGES LIST FILE ___________________________________________________

/your/path/to/package_list.txt

CHANGES DIFF ___________________________________________________________________

--- previous Wed May  4 22:59:51 2011
+++ current  Thu May  5 10:30:01 2011
@@ -34,1 +34,1 @@
-ii  apt                 0.7.25.3ubuntu9.3
+ii  apt                 0.7.25.3ubuntu9.4
@@ -36,2 +36,2 @@
-ii  apt-transport-https 0.7.25.3ubuntu9.3
-ii  apt-utils           0.7.25.3ubuntu9.3
+ii  apt-transport-https 0.7.25.3ubuntu9.4
+ii  apt-utils           0.7.25.3ubuntu9.4

END TIME =======================================================================
                                                     Thursday 05/05/11, 10:30:01
 ===============================================================================

Donde se puede ver la información que nos indica el script que ha generado el correo, la maquina en la que se han realizado los cambios, la localización del fichero con la relación de todos los paquetes instalados en el sistema, la fecha y hora de la ejecución del script y el diff con la relación de cambios en los paquetes en formato Unified format. En este ejemplo podemos ver como se han actualizado tres paquetes en esa maquina. No nos dice la hora en que se efectuó la modificación (podemos verlo en el log de dpkg) pero si podemos saber que se efectuó entre dos intervalos de ejecución del script, información que será más que suficiente la mayoría de las veces. Para datos concretos, ir al log y filtrarlo con grep y en segundos sabremos la respuesta. Si además como es mi caso, ejecutamos el script cada 12 o 24 horas, pues será fácil saber cuando se han realizado los cambios.

Un fragmento de código de la parte principal del script es el siguiente:

def pretty_diff(diff):
    """Better format for package lines in diff."""
    pkg = {} # diff's packages lines

    # Get columns info for diff package lines
    for idx, line in enumerate(diff):
        if not findall("^-{3}|^\+{3}|^@{2}", line):
            # split the line in columns and remove the description column
            cols = split("\s{2,}", line, 3)[:3]
            # A nested dict, for each line index we have a dict that contains 
            # the package line columns: 's' (status), 'n' (name) & 'v' (version)
            # and the width of the name column: w(width)
            pkg[idx] = {'s':cols[0], 'n':cols[1], 'v':cols[2], 'w':len(cols[1])}

    # maximum width in packages' name column for all lines
    mxw = max((pkg[index]['w'] for index in pkg))

    # Replace each package line for a prettier one (more legible) 
    for i in range(len(diff)):
        if i in pkg:
            diff[i] = ("{0} {1} {2}".format(pkg[i]['s'], pkg[i]['n'] + " " *
                                            (mxw - pkg[i]['w']), pkg[i]['v']))
    return diff

def main(old=""):
    """Main section"""

    # The path to store the debian packages list file
    pkg_lst_file = "./package_list.txt"

    # Start logging
    log = Logger()
    url = "http://code.joedicastro.com/python-recipes"
    head = "Changes of packages installed on {0}".format(platform.node())
    log.header(url, head)
    log.time("Start time")

    # Read the old file and clean the list
    if os.path.exists(pkg_lst_file):
        old = open(pkg_lst_file, 'r').readlines()
        old_date = time.ctime(os.stat(pkg_lst_file).st_mtime)

    # Get the current list of debian packages installed on system 
    current = Popen(["dpkg", "-l"], stdout=PIPE).stdout.readlines()

    # First, save the list file
    with open(pkg_lst_file, 'w') as out:
        out.writelines(current)
        curr_date = time.ctime(os.stat(pkg_lst_file).st_mtime)

    # Compare both lists
    if old:
        file_path = os.path.realpath(pkg_lst_file)
        diff = [ln for ln in unified_diff(old, current, fromfile="previous",
                                          tofile="current ",
                                          fromfiledate=old_date,
                                          tofiledate=curr_date, n=0,
                                          lineterm="")]

        # If there are differences write the log to disk and send mail
        if diff:
            log.list("Installed packages list file", file_path)
            log.list("Changes diff", pretty_diff(diff))
            log.time("End time")
            log.write(True)
            # Send mail to current system user. For other options, see logger 
            # module info
            log.send("Debian packages changes")

Este script hace uso del modulo logger, que comento en este artículo.

Para obtener la versión más reciente del script y del modulo logger, consultar mi repositorio.

Es una relación de los programas instalados empleando el sistema de paqueteria de Debian, los programas instalados manualmente vía compilación u otros medios no aparecerán en ella. ↩

Python one-liners. Potencia en una sola línea

2011-05-02T22:18:00+02:00

Un one-liner propiamente dicho es un comando de la consola que ejecuta una determinada función en "una sola línea de texto". En Python esto se consigue con una única orden de línea de comandos que llama al interprete y ejecuta los argumentos que le pasemos en la misma. Aunque también se les denomina así a veces a funciones lambda y funciones que han sido reducidas a una sola linea de código.

Un ejemplo de python one-liner es uno de los más famosos:

python -m this

Y que nos devuelve el popular Zen of Python:

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Pero existen varios one-liners muy útiles que nos pueden hacer la vida más fácil para determinadas tareas.

Iniciar un servidor web y compartir un directorio

python -m SimpleHTTPServer

Si ejecutamos este one-liner se iniciará un servidor web en el puerto 8000 de nuestra dirección local (localhost o 127.0.0.1) que nos servirá los archivos del directorio donde lo ejecutemos. Para ello solo tenemos que acceder desde nuestro navegador a la dirección http://localhost:8000 o http://127.0.0.1. Para interrumpir el servicio basta con que interrumpamos el programa con Ctrl+C. Si quisiéramos emplear un puerto distinto de 8000, por ejemplo 8080, solo tenemos que indicarselo:

python -m SimpleHTTPServer 8080

Iniciar un servidor SMTP

python -m smtpd -n -c DebuggingServer localhost:25

Con este comando iniciamos un servidor de correo SMTP. Es básico, pero puede ser muy útil para crear un entorno temporal de pruebas. Dependiendo de la configuración de nuestro sistema, es muy probable que necesitemos ejecutar este comando como administrador (root). Si ya tenemos corriendo un servidor de correo en ese puerto, podemos cambiarlo por otro (eg: 2525)

Iniciar un servidor FTP

python -m pyftpdlib.ftpserver

Para poder ejecutar este comando es necesario tener instalada la librería pyftpdlib. Debemos además ser usuario con permisos de administrador de la maquina para poder iniciar este servidor. Una vez ejecutado tendremos un servidor FTP de solo lectura en el directorio en el que lo iniciemos.

Ejecutar un cliente FTP

python -m ftplib

Si ejecutamos este comando, nos devolverá la ayuda con los argumentos necesarios para poder conectarnos a un servidor FTP.

Abrir una página web en el navegador

python -m webbrowser http://joedicastro.com

Nos abrirá la dirección web que le indiquemos en el navegador web predeterminado de nuestro equipo.

Obtener el código fuente de una página web

python -m urllib http://example.com

Esto nos imprime en pantalla el código fuente (HTML) de una dirección web.

Eliminar las etiquetas HTML de un fichero HTML

python -m htmllib test.html

Esto nos imprime el contenido del fichero test-html pero sin mostrarnos las etiquetas HTML, solo texto plano. Algo parecido a lo que hace un navegador en modo texto como links, pero de forma estática.

Comparar dos directorios

python -m filecmp dir_1 dir_2

De esta manera podemos comparar dos directorios. El resultado será un resumen de que ficheros son iguales, cuales diferentes y lo mismo con los subdirectorios.

Identificar la plataforma

python -c 'from sys import platform; print platform'

Este nos sirve para identificar la plataforma sobre la que se ejecuta el comando (Windows, Linux, ...) No es de mucha utilidad, pero nos sirve como curiosidad. Otra opción más simple y que nos devuelve un resultado más completo sería:

python -m platform

Obtener el nombre de la maquina (hostname)

python -c 'from socket import gethostname; print gethostname()'

python -c 'import platform; print platform.node()'

Cualquiera de estos dos one-liners nos devolverán el nombre de la maquina en que los ejecutemos.

Imprimir el calendario del año en curso

python -m calendar

Imprime en pantalla el calendario de todo el año. Para conocer más opciones, como imprimir el calendario de otro año, mes, etc añadir la opción -h al final de la línea.

Mostrar los módulos empleados en un script

python -m modulefinder script.py

De esta manera podemos no solo saber que módulos son importados por el script, si no que además nos muestra su ruta en el sistema de archivos.

Aquí he mencionado solo algunos que empleo con cierta frecuencia o que me han parecido reseñables, pero existen bastantes más. Una buena pista es que la mayoría hace uso de los módulos de la librería estándar de Python.

Como funciona

Básicamente se trata de llamar al interprete Python utilizando uno de los siguientes argumentos:

-c: Lo que seguiría a esta opción sería un programa Python encerrado entre comillas. Por ejemplo, el primer ejemplo quedaría de este modo, python -c 'import this'
-m: Está opción llama a un modulo de python, que puede a su vez tener distintas opciones y argumentos, y lo ejecuta como script. Por ejemplo: python -m locale

HTTPS Server

Este no es un one-liner en Python, pero sirve como complemento a los distintos servidores que hemos visto que se podían iniciar con mucha facilidad gracias a Python. Este código inicia un servidor HTTPS en Python en el puerto 4443 de la dirección local. Lo suyo sería iniciarlo en el puerto 443, y se puede hacer simplemente cambiándolo, pero se necesitan entonces permisos de administrador para iniciarlo.

import BaseHTTPServer, SimpleHTTPServer
import ssl

httpd = BaseHTTPServer.HTTPServer(('localhost', 4443),
                                  SimpleHTTPServer.SimpleHTTPRequestHandler)
httpd.socket = ssl.wrap_socket (httpd.socket, 
                                certfile='path/to/localhost.pem', 
                                server_side=True)
httpd.serve_forever()

El código es original de Martin Pitt y me ha servido en más de una ocasión para probar un script.

Editar una página web con javascript

No es un one-liner escrito en Python, si no en javascript, pero lo menciono aquí a modo de curiosidad porque siempre me ha parecido curioso y aparentemente inútil, pero tiene sus aplicaciones (alguna broma ha caído gracias a él).

javascript:document.body.contentEditable='true'; document.designMode='on'; void 0

Para ejecutarlo es muy sencillo. Abrimos nuestro navegador web favorito, abrimos la página web que deseamos editar y luego simplemente sustituimos el texto de la barra de direcciones por el de este one-liner y pulsamos Enter. Ahora podemos editar la página web como si fuera un procesador de texto.

Comprobar si un programa está instalado con Python

2011-04-28T14:04:00+02:00

Cuando creamos un script en Python, sobre todo aquellos orientados a ejecutarse en la línea de comandos, a veces necesitamos echar mano de un programa externo que no siempre viene por defecto instalado en el sistema. Por ejemplo, en el script que empleo en optimizar imágenes para la web empleo los programas externos pngcrush y jpegtran. ¿Como comprobamos entonces si el programa está instalado? Desde luego es siempre mejor comprobarlo y avisar al usuario, que dejar que arroje un feo error.

Una forma de comprobar si el programa está instalado es capturando la excepción cuando se produzca con las sentencias try y except, incluyendo la llamada al ejecutable dentro de ellas y devolver un mensaje de error avisando de la necesidad de la presencia de este ejecutable. Pero al igual que en el ejemplo anterior, yo prefiero comprobar esto incluso antes de ejecutar cualquier otro código dentro del script. Para ello empleo el conocido truco que nos permite ejecutar cierto código solo cuando es ejecutado como script y no cuando es importado como módulo:

if __name__ == "__main__":
   chequeo_ejecutable()
   main()

Donde main() es la función principal donde albergaríamos el código fundamental del script. Es un conocido Python Idiom que me sirve perfectamente para esta tarea. De hecho lo empleo habitualmente en todos mis scripts para separar el código principal de las funciones.

Comprobar en Linux si existe el ejecutable es realmente sencillo (siempre y cuando conozcamos el nombre exacto del ejecutable) con este código:

#!/usr/bin/env python
# -*- coding: utf8 -*-

import sys
from subprocess import Popen, PIPE

def check_execs(*progs):
    """Check if the programs are installed, if not exit and report."""
    for prog in progs:
        try:
            Popen([prog, '--help'], stdout=PIPE, stderr=PIPE)
        except OSError:
            msg = 'The {0} program is necessary to run this script'.format(prog)
            sys.exit(msg)
    return

def main():
    # Incluir aquí el código fundamental del script
    pass

if __name__ == "__main__":
    check_execs('python')
    main()

Si no existiera el ejecutable que le pasamos a la función check_execs() entonces se detendrá el script y nos dirá que necesitamos instalarlo para ejecutar el script. Hacerlo así nos evita cualquier tipo de manipulación previa antes de darnos cuenta de que nos falta un elemento esencial para ejecutarlo al completo. Esta función funciona porque en Linux los ejecutables normalmente están colgando de una ruta del PATH. En Windows, por ejemplo, la cosa cambia.

Si queremos que el script sea multiplataforma y que nos funcione tanto en sistemas *NIX como en Windows entonces necesitamos una función algo más compleja. En Windows un ejecutable no necesita colgar del PATH y es muy frecuente que no sea así. Al mismo tiempo en Windows podemos tener el sistema de ficheros repartido en varias unidades de disco, y necesitamos explorar todas ellas para buscar nuestro ejecutable. Aunque lo más frecuente es que se encuentre en la unidad C: y la función se detiene en cuanto encuentra el primer ejecutable, el hecho de realizar está búsqueda hace que el proceso sea más lento en Windows que en Linux.

La función multiplataforma es la siguiente:

def check_execs_posix_win(progs):
    """Check if the program is installed.

    Returns one  dictionary with 1+n pair of key/values:

    A fixed key/value:

    "WinOS" -- (boolean) True it's a Windows OS, False it's a *nix OS

    for each program in progs a key/value like this:

    "program"  -- (str or boolean) The Windows executable path if founded else 
                                   '' if it's Windows OS. If it's a *NIX OS True
                                   if founded else False

    """
    execs = {'WinOS':True if platform.system() == 'Windows' else False}
    # get all the drive unit letters if the OS is Windows
    windows_drives = findall(r'(\w:)\\',
                             Popen('fsutil fsinfo drives', stdout=PIPE).
                             communicate()[0]) if execs['WinOS'] else None

    progs = [progs] if isinstance(progs, str) else progs
    for prog in progs:
        if execs['WinOS']:
            # Set all commands to search the executable in all drives
            win_cmds = ['dir /B /S {0}\*{1}.exe'.format(letter, prog) for
                        letter in windows_drives]
            # Get the first location (usually in C:) where the executable exists
            for cmd in win_cmds:
                execs[prog] = (Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True).
                               communicate()[0].split(os.linesep)[0])
                if execs[prog]:
                    break
        else:
            try:
                Popen([prog, '--help'], stdout=PIPE, stderr=PIPE)
                execs[prog] = True
            except OSError:
                execs[prog] = False
    return execs

En la parte de Windows (la de *NIX es básicamente igual) esta función lo que hace es obtener primero las letras de las unidades de disco disponibles en el sistema. Luego busca el ejecutable en cada una de ellas y en cuanto encuentra la primera ruta al ejecutable se detiene. La función en este caso devuelve un diccionario donde hay una clave fija que es WinOS que será True si estamos en Windows y False en caso contrario. Luego nos devuelve una clave por cada uno de los programas que le mandemos comprobar. Esta clave sera booleana en el caso de *NIX y la ruta del programa (o una cadena vacía) en el caso de Windows.

Las funciones y un ejemplo de su funcionamiento podéis encontrarlas en mi repositorio

Crear un arbol de directorios falso para entorno de pruebas

2011-04-27T20:52:00+02:00

A veces, para realizar pruebas con nuestros propios programas o para, por ejemplo, hacer pruebas con programas de Backup o FTP, necesitamos crear un entorno de pruebas que nos permita hacer todo tipo de operaciones sin comprometer la seguridad de nuestros datos reales. Una practica habitual es hacer copias de directorios de nuestros propios archivos y trabajar sobre ellos. Es algo que creo se debería dejar únicamente para la última fase de las pruebas, cuando en teoría ya todo funciona. Confundir ubicaciones y malograr los datos reales es más fácil de lo que pueda parecer, sobre todo si se comparte el mismo sistema de archivos. Otra veces lo que necesitamos es generar una estructura de directorios totalmente aleatoria, con sus correspondientes archivos de forma temporal.

He creado un script Python que hace precisamente esto último, generar una jerarquía completa de directorios, de forma aleatoria, con sus correspondientes archivos de texto para simular una estructura de directorios real. Cuando le estaba dando vueltas a como generar de forma aleatoria los nombres de los archivos y que al mismo tiempo fuera multiplataforma (respetando los caracteres no permitidos según el sistema de archivos) me acorde de Lorem Ipsum. El texto que se lleva empleando desde los tiempos de la imprenta para generar borradores y que aún se emplea en diseño gráfico para los contenidos de prueba (al igual que en la web). No solo hacía de este modo un guiño a esta veterana prueba de maquetación, si no que me solucionaba la papeleta de generar los nombres de directorios y archivos. Al estar compuesto de "palabras" en latín (solo caracteres del alfabeto) me olvidaba de las incompatibilidades entre plataformas y sistemas de archivo. Un homenaje y un problema resuelto en un solo paso.

Cuando me disponía ya a crear un modo de extraer palabras aleatorias del texto original de Lorem Ipsum, pensé que seguro que no era el primero al que se le ocurría hacer esto con Python, así que después de una pequeña búsqueda en el PyPI, di con el magnifico proyecto de James Hales, Lorem-Ipsum-Generator. Importando el modulo de este proyecto en mi script, tenía medio trabajo hecho.

El script, al que llamo test_dir_tree, genera una estructura de directorios de entre 7 y 39 directorios (estos parámetros pueden ser fácilmente cambiados en el script), con sus correspondientes archivos. El número de archivos se decide en función del número de directorios y se reparten también de forma aleatoria entre los mismos. Como he comentado, los nombres tanto de directorios como ficheros proceden de Lorem Ipsum. El tamaño de los archivos oscila entre 3 y 512 Kbytes, para no ocupar demasiado espacio en disco. Son archivos de texto normales en los cuales el contenido está formado a su vez por párrafos aleatorios de Lorem Ipsum.

No es necesario ningún parámetro para ejecutar el script:

python test_dir_tree.py

Una vez ejecutado el script, se genera una estructura de directorios como la de este ejemplo:

test
├── blandit
│   ├── [234K]  bibendum.txt
│   ├── [319K]  congue.txt
│   ├── [382K]  consequat.txt
│   └── [298K]  ligula.txt
├── elit
├── est
│   ├── [ 22K]  condimentum.txt
│   ├── [401K]  hac.txt
│   ├── [139K]  nibh.txt
│   └── [ 12K]  tincidunt.txt
├── habitasse
│   ├── [359K]  etiam.txt
│   ├── [ 59K]  facilisi.txt
│   ├── [ 12K]  integer.txt
│   ├── [ 23K]  metus.txt
│   └── [ 31K]  non.txt
├── lacus
│   ├── [394K]  faucibus.txt
│   └── [ 29K]  torquent.txt
├── laoreet
│   └── [424K]  eros.txt
├── litora
│   └── [ 87K]  tellus.txt
└── nostra
    ├── [349K]  curabitur.txt
    ├── [241K]  neque.txt
    ├── [3.4K]  odio.txt
    └── [ 78K]  sapien.txt

Donde el principio del contenido de uno de esos archivos de texto, sería algo así:

Eget. Sem turpis tempus sagittis arcu, nullam ac rutrum turpis. Sem
fusce lacus, cum neque fermentum potenti. Est aliquam donec, leo
amet elit dapibus ipsum. Quam pellentesque eu fusce pellentesque
torquent netus vivamus velit at nisl. Senectus ligula, erat dictum.
Natoque metus urna quis vivamus in duis. Cras. Massa nam. Quisque.
Potenti, sit. Urna metus, et eu duis suspendisse per primis. Duis,
viverra massa enim hac.

Fames ut leo in a turpis proin gravida ac, auctor. Natoque
suspendisse nisl. Dictumst mus, amet pede, eni velit velit. Elit.
Cum. Congue pretium ad id porta in massa enim purus. Tempus, porta
donec molestie habitasse, urna urna nam. Tempor massa sed quam sit
nec dapibus at, duis. Leo pellentesque. Orci arcu iaculis ac, elit
netus conubia. Penatibus platea rutrum netus suspendisse non. Purus
consequat. Inceptos platea, tempus metus eu consectetuer feugiat,
urna at lorem pellentesque curae. Dapibus a, scelerisque cum, auctor
 tincidunt primis. Augue nisi id per nulla, sit enim mus id eleifend
 taciti, semper est.

El script tarda muy poco en generar esta estructura, por ejemplo en un Core 2 Duo a 2 GHz, se tardan 1.72s en generar una estructura de 71 directorios y 114 ficheros.

Este es el núcleo central del script test_dir_tree.py:

def test_tree(path, min_dirs=7, max_dirs=79):
    """make a fake directory hierarchy with files for test purposes."""

    def latin_words(generator):
        """Generate a list of latin words"""
        words = generator.generate_paragraphs_plain(9).lower()
        return list(set(words.replace('.', '').replace(',', '').split()))

    def check_path(path):
        """If no exists a path, make it."""
        if not os.path.exists(path):
            os.mkdir(path)

    lorem = lipsum.MarkupGenerator()
    latins = latin_words(lorem)

    dirs = latins[:randrange(min_dirs, max_dirs)]
    files = [f for f in latins if f not in dirs][:len((dirs) * 3) - 3]

    check_path(path)
    for directory in dirs:
        check_path(os.path.join(path, directory))

    for fil in files:
        filename = os.path.join(path, choice(dirs), '{0}.txt'.format(fil))
        text = ''
        size = randint(3, 524288) # Files not bigger than 512 Kbytes
        sample = lorem.generate_paragraphs_plain(randrange(3, 9))
        while len(text) < size:
            text += sample + os.linesep * 2
        with open(filename, 'w') as out:
            out.write(text[:size])

    return dirs, files

Para obtener el script completo, acudir a mi repositorio.

Mover todos los archivos del mismo tipo de un arbol de directorios a la vez

2011-04-26T23:17:00+02:00

A veces tenemos la necesidad de mover (o copiar o borrar) varios ficheros del mismo tipo a la vez, pero estos no "cuelgan" de un solo directorio, si no que se encuentran repartidos dentro una jerarquía de subdirectorios. En este caso los típicos comandos para mover/copiar/borrar archivos no nos sirven, ni siquiera los útiles comodines nos resuelven el problema. ¿Como lo hacemos entonces?

Por ejemplo, si tenemos una estructura de directorios como esta:

raiz
├── dir_1
│   ├── imagen_1.jpg
│   ├── pdf_1.pdf
│   ├── texto_1.txt
│   └── texto_2.txt
├── dir_2
│   ├── imagen_2.jpg
│   ├── imagen_3.gif
│   └── texto_3.txt
├── dir_3
│   ├── doc_1.doc
│   ├── pdf_2.pdf
│   ├── pdf_3.pdf
│   ├── pdf_4.pdf
│   ├── texto_4.txt
│   └── texto_5.txt
├── dir_4
│   ├── subdir_1
│   │   └── imagen_4.png
│   ├── subdir_2
│   │   ├── pdf_5.pdf
│   │   └── texto_7.txt
│   ├── doc_2.doc
│   └── texto_6.txt
└── dir_5

Y queremos mover todos los ficheros .txt al dir_5 que tenemos vacío, ¿Como lo hacemos? Bueno, en el caso de Linux (y UNIX) podemos hacerlo en una sola operación gracias al siempre útil y versátil find con el siguiente comando (ejecutado desde el directorio raíz):

find . -type f -name *.txt -exec mv {} ./dir_5 \;

Este comando nos encontraría todos los archivos con la extensión .txt dentro de todos los directorios y subdirectorios y los iría moviendo uno a uno al dir_5. Es un comando rápido y efectivo. Genéricamente, el comando sería así:

find directorio_origen -type f -name *.EXT -exec mv {} ./directorio_destino \;

donde EXT sería la extensión del tipo de archivo que queremos mover. Se puede emplear esta variante para copiar los archivos en vez de moverlos:

find directorio_origen -type f -name *.EXT -exec cp {} ./directorio_destino \;

Y esta otra para eliminarlos (¡emplear con cuidado!):

find directorio_origen -type f -name *.EXT -exec rm -f {} \;

Partiendo de la idea de hacer algo equivalente en Python, he creado un script que hace algo similar a esto, sin la necesidad de teclear todo el comando (y con el riesgo a equivocarse y liarla parda) y que también sirve para que los no trabajen habitualmente con la consola no necesiten recordar (o anotar) esos comandos.

La parte principal del script move_by_ext.py es la siguiente:

def find_and_process(args, count=0, log=""):
    """Find the files by file extension and process (move/copy/remove) them."""

    def process(the_path, the_file):
        """Process each file."""
        processed = 0
        src_file = os.path.join(the_path, the_file)
        dst_file = os.path.join(args.dst, the_file)
        if args.rm:
            os.remove(src_file)
            processed = 1
        else:
            if not os.path.exists(dst_file): # not replace if already exists 
                if args.cp:
                    shutil.copy2(src_file, dst_file)
                else:
                    shutil.move(src_file, dst_file)
                processed = 1
        return processed

    if not os.path.exists(args.dst):
        os.mkdir(args.dst)
    for path, directories, files in os.walk(args.src):
        for fil in files:
            # ignore files without extension (can have the same name as the ext)
            file_ext = fil.split('.')[-1] if len(fil.split('.')) > 1 else None
            # ignore dots in given extensions
            extensions = [ext.replace('.', '') for ext in args.ext]
            if file_ext in extensions:
                count += process(path, fil)

    opt = int("{0}{1}".format(int(args.rm), int(args.cp)), 2)
    log = "Files {0}: {1}".format({0:"moved", 1:"copied", 2:"removed"}[opt], count)
    return log

Este script nos permite realizar las mismas operaciones que los comandos anteriores y además tiene dos ventajas adicionales:

Permite emplear varias extensiones a la vez, lo que nos permite mover/copiar/borrar distintos tipos de archivo en una sola operación. Por ejemplo si queremos mover todos los tipos de imagen de la estructura de directorios anterior, podríamos hacerlo indicándole que emplee las extensiones .jpg, .gif y .png en la misma operación. El comando sería el siguiente (las extensiones pueden llevar o no el punto, funciona exactamente igual), ejecutado desde el directorio raíz:

python move_by_ext.py jpg .gif png -d ./dir_5
Funciona en Windows. A diferencia del comando para Linux, este se puede emplear en Windows sin necesidad de instalar ningún entorno que nos simule un shell Linux (como Cygwin) y solo es necesario tener instalado Python 2.7

La sintaxis del script es muy sencilla y se puede ver reflejada en la ayuda del mismo:

$ python move_by_ext.py -h
usage: move_by_ext.py ext [-s SRC] [-d DST] [-c | -r] [--help]

Move (or copy/remove) all files selected by extension into a directory tree to
a destination directory.

positional arguments:
  ext                the extension(s) of the files to process. To use more
                     than one extension, separate them with a space

optional arguments:
  -h, --help         show this help message and exit
  -s SRC, --src SRC  the source path. Current dir if none is provided
  -d DST, --dst DST  the destination path. Current dir if none is provided
  -c, --copy         copy all the files with the given extension(s) to the
                     destination directory.
  -r, --remove       remove all the files with the given extension(s). Use
                     with caution! remove also in the subdirectories
  -v, --version      show program's version number and exit

El script completo puede encontrarse en mi repositorio.

Comparativa de Lenguajes de marcado ligero

2011-04-02T20:29:00+02:00

Esta es una comparativa de los lenguajes de marcado ligero más empleados de los disponibles actualmente. Dicha comparativa surge a partir de este articulo, Markdown, la mejor opción para crear contenidos web, donde defiendo la idoneidad de markdown para crear contenidos web.

En esta comparativa se verá como emplear cada uno de los lenguajes de marcado disponibles para crear un contenido web similar. Tomo como referencia a markdown, aunque no todos los lenguajes soportan todas o las mismas características que este.

Documento de ejemplo realizado con Markdown

Markdown

Resultado

Documento de ejemplo
====================
Lorem ipsum [dolor sit amet](#mark), consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.
Sed nibh quam, hendrerit _sit amet aliquam_ vel, pulvinar molestie augue.
> Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.
Lenguajes de marcado ligero
 * **Markdown**
 * Textile
 * reStructuredText
 * Texy!
 * Txt2tags
 * Marcado Wiki
   1. Creole
   2. MediaWiki
![avatar](pictures/no_wysiwyg.png)
### Cabecera H3 ###
- - -
Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.
|   | solo texto | HTML Limpio  |
| -------------- | -- | ------- |
| Markdown       | Si | Si      |
| Editor WYSISWG | X  | A veces |
_Ejemplo de código_
    import lifetime
     
    for each_day in lifetime.days():
        carpe_diem()
Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.
Esto es un texto con nota al pie [^ejemplo] y esta es otra nota [^segunda]

 *[vehicula]: automobila
[^ejemplo]: Esto es una nota al pie.
[^segunda]: Esto es la segunda nota.

Documento de ejemplo

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum semper adipiscing leo et blandit.

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lenguajes de marcado ligero

Markdown
Textile
reStructuredText
Texy!
Txt2tags
Marcado Wiki
1. Creole
2. MediaWiki

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

Ejemplo de código

import lifetime
 
for each_day in lifetime.days():
    carpe_diem()

Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie ¹ y esta es otra nota ²

Esto es una nota al pie. ↩
Esto es la segunda nota. ↩

Textile

Es una buena alternativa a Markdown y bastante extendido, aunque quizás menos que Markdown. Tiene algunas posibilidades que no tiene Markdown como emplear colores, poder alinear el texto o emplear superindice y subindice. También tiene carencias como el no poder dibujar líneas horizontales o el poder emplear acronimos solo con mayusculas y tener que declararlos en cada una de las partes del texto que aparezcan. Pero quiźas para mi la mayor desventaja es la menor legibilidad del texto, es menos evidente a un vistazo que markdown.

Textile

Resultado

h1. Documento de ejemplo

Lorem ipsum "dolor sit amet":#mark, consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.

Sed nibh quam, hendrerit _sit amet aliquam_ vel, pulvinar molestie augue.

bq. Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.

Lenguajes de marcado ligero

* **Markdown**
* Textile
* reStructuredText
* Texy!
* Txt2tags
* Marcado Wiki
## Creole
## MediaWiki

!pictures/no_wysiwyg.png (avatar)!

h3. Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

|_. @@|_. solo texto|_. HTML Limpio|
|Markdown|Si|Si|
|Editor WYSISWG|X|A veces|

_Ejemplo de código_

bc.. import lifetime

for each_day in lifetime.days():
    carpe_diem()

p. Suspendisse posuere velit et velit VEHICULA(automobila) at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie[1] y esta es otra nota[2]

fn1. Esto es una nota al pie.

fn2. Esto es la segunda nota.

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lenguajes de marcado ligero

Markdown
Textile
reStructuredText
Texy!
Txt2tags
Marcado Wiki
1. Creole
2. MediaWiki

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

Ejemplo de código

import lifetime

for each_day in lifetime.days():
    carpe_diem()

Suspendisse posuere velit et velit VEHICULA at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie¹ y esta es otra nota²

¹ Esto es una nota al pie.

² Esto es la segunda nota.

BBCode

Es uno de los más extendido porque es ampliamente usado en foros por toda la red. Nació para ser empleado en foros y es prácticamente el único ámbito en el que se emplea. Es también muy limitado porque no soporta muchas de las características de los otros lenguajes y además hay múltiples variantes que no ayudan a crear un estándar. Por ejemplo las listas y las tablas no son contempladas en algunas de esas variantes.

BBCode	Resultado
Documento de ejemplo Lorem ipsum [url=http://joedicastro.com]dolor sit amet[/url], consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum [b]semper adipiscing leo[/b] et blandit. Sed nibh quam, hendrerit [i]sit amet aliquam[/i] vel, pulvinar molestie augue. [quote]Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.[/quote] [img]http://joedicastro/files/ imagenes/no_wysiwyg.png[/img] Cabecera H3 Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet. [i]Ejemplo de codigo[/i] [code] import lifetime for each_day in lifetime.days(): carpe_diem() [/code]	Documento de ejemplo Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum semper adipiscing leo et blandit. Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue. Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc. Cabecera H3 Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet. Ejemplo de codigo import lifetime for each_day in lifetime.days(): carpe_diem()

BBCode

Resultado

Documento de ejemplo

Lorem ipsum [url=http://joedicastro.com]dolor sit amet[/url], consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum [b]semper adipiscing leo[/b] et blandit.

Sed nibh quam, hendrerit [i]sit amet aliquam[/i] vel, pulvinar molestie augue.

[quote]Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.[/quote]

[img]http://joedicastro/files/
imagenes/no_wysiwyg.png[/img]

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

[i]Ejemplo de codigo[/i]

[code]
import lifetime

for each_day in lifetime.days():
    carpe_diem()
[/code]

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

Ejemplo de codigo

import lifetime

for each_day in lifetime.days():
carpe_diem()

reStructuredText

Fue creado para crear documentación, en concreto documentación para lenguajes de programación como Python. Tiene algunas carencias al no estar orientado a HTML, pero también tiene posibilidades de las que carece Markdown. Es muy potente, bastante legible, pero un poco incomodo para según que cosas, a mi modo de ver.

reStructuredText

Resultado

Documento de ejemplo
====================

Lorem ipsum `dolor sit amet <#mark>`_, consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.

Sed nibh quam, hendrerit *sit amet aliquam* vel, pulvinar molestie augue.

Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.

Lenguajes de marcado ligero

 * **Markdown**
 * Textile
 * reStructuredText
 * Texy!
 * Txt2tags
 * Marcado Wiki

   1. Creole
   2. MediaWiki

.. image:: pictures/no_wysiwyg.png
   :alt: avatar

---------------

Cabecera H3
^^^^^^^^^^^

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

============== ========== ===========
\              solo texto HTML Limpio
============== ========== ===========
Markdown           Si         Si      
Editor WYSISWG     X        A veces 
============== ========== ===========

*Ejemplo de código*::

    import lifetime

    for each_day in lifetime.days():
        carpe_diem()

Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie [1]_ y esta es otra nota [2]_

.. [1] Esto es una nota al pie.
.. [2] Esto es la segunda nota.

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lenguajes de marcado ligero

Markdown
Textile
reStructuredText
Texy!
Txt2tags
Marcado Wiki
1. Creole
2. MediaWiki

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

Ejemplo de código:

import lifetime

for each_day in lifetime.days():
    carpe_diem()

Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie ¹ y esta es otra nota ²

Esto es una nota al pie. ↩
Esto es la segunda nota. ↩

Texy!

Fue específicamente diseñado para crear documentos XHTML, por ello es bastante completo, pero no está muy extendido. Es legible, pero también tiene carece de soporte para ciertos tags de HTML.

Texy!

Resultado

Documento de ejemplo
====================

Lorem ipsum [dolor sit amet | http://joedicastro.com], consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.

Sed nibh quam, hendrerit *sit amet aliquam* vel, pulvinar molestie augue.

> Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.

Lenguajes de marcado ligero

- **Markdown**
- Textile
- reStructuredText
- Texy!
- Txt2tags
- Marcado Wiki
 1) Creole
 2) MediaWiki

[* pictures/no_wysiwyg.png .(alt text)[avatar] *]

### Cabecera H3 ###

-----

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

|------------------------------
|   | solo texto | HTML Limpio  
|------------------------------
| Markdown       | Si | Si      
| Editor WYSISWG | X  | A veces

*Ejemplo de código*

/---code
  import lifetime

  for each_day in lifetime.days():
      carpe_diem()
\---

Suspendisse posuere velit et velit "vehicula"((automobila)) at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lenguajes de marcado ligero

Markdown
Textile
reStructuredText
Texy!
Txt2tags
Marcado Wiki
1. Creole
2. MediaWiki

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

Ejemplo de código

import lifetime

for each_day in lifetime.days():
    carpe_diem()

Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

txt2tags

Está escrito en Python y es muy potente, al igual que RestructuredText, permitiendo macros. Permite la salida en muchos formatos, incluido el XHTML. Es muy legible y muy fácil de emplear, es una pena que no esté más extendido y soportado. Aunque aún tiene algunas carencias como las notas al pie o las abreviaturas, que pueden ser soportadas con macros, también tiene un desarrollo muy activo. En la futura versión 3.0 serán soportados directamente las notas al pie. Es una alternativa con muy buen futuro.

txt2tags

Resultado

=Documento de ejemplo=

Lorem ipsum [dolor sit amet #mark], consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.

Sed nibh quam, hendrerit //sit amet aliquam// vel, pulvinar molestie augue.

Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.

Lenguajes de marcado ligero

- **Markdown**
 - Textile
 - reStructuredText
 - Texy!
 - Txt2tags
 - Marcado Wiki
  + Creole
  + MediaWiki

[pictures/no_wysiwyg.png]

===Cabecera H3===

--------------------

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

||   | solo texto | HTML Limpio
| Markdown       |  Si  |  Si  |
| Editor WYSISWG |  X  |  A veces  |

//Ejemplo de codigo//

```
import lifetime

for each_day in lifetime.days():
    carpe_diem()
```

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lenguajes de marcado ligero

Markdown
Textile
reStructuredText
Texy!
Txt2tags
Marcado Wiki
1. Creole
2. MediaWiki

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

Ejemplo de codigo

import lifetime

for each_day in lifetime.days():
    carpe_diem()

Creole

Creado a partir de los lenguajes más empleados en los Wikis y usado fundamentalmente en Wikis, por lo que también tiene ciertas carencias.

Creole

Resultado

== Documento de ejemplo ==

Lorem ipsum [[#mark|dolor sit amet]], consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.

Sed nibh quam, hendrerit //sit amet aliquam// vel, pulvinar molestie augue.

> Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.

Lenguajes de marcado ligero

* **Markdown**
 * Textile
 * reStructuredText
 * Texy!
 * Txt2tags
 * Marcado Wiki
 ## Creole
 ## MediaWiki

{{pictures/no_wysiwyg.png|avatar}}

==== Cabecera H3 ====

-----

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

|= |= solo texto |= HTML Limpio |
| Markdown       | Si | Si      |
| Editor WYSISWG | X  | A veces |

//Ejemplo de código//
{{{
import lifetime

for each_day in lifetime.days():
    carpe_diem()
}}}

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lenguajes de marcado ligero

Markdown
Textile
reStructuredText
Texy!
Txt2tags
Marcado Wiki
1. Creole
2. MediaWiki

Cabecera H3

-----

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

Ejemplo de código

import lifetime

for each_day in lifetime.days():
    carpe_diem()

MediaWiki

Quizás el más extendido, no en vano MediaWiki es el Wiki empleado por la Wikipedia. Igual que Creole, tiene ciertas limitaciones que suple con plugins y etiquetas HTML. No me acaba de gustar. La manera que tiene de crear tablas - por ejemplo - aunque potente, no me parece nada legible en texto plano.

MediaWiki

Resultado

==Documento de ejemplo==

Lorem ipsum [http://joedicastro.com dolor sit amet], consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum '''semper adipiscing leo''' et blandit.

Sed nibh quam, hendrerit ''sit amet aliquam'' vel, pulvinar molestie augue.

Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.

Lenguajes de marcado ligero

* '''Markdown'''
* Textile
* reStructuredText
* Texy!
* Txt2tags
* Marcado Wiki
*# Creole
*# MediaWiki

[[File:pictures/no_wysiwyg.png|caption]]

=== Cabecera H3 ===

----

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

{| 
! 
! solo texto
! HTML Limpio
|-
|Markdown
|Si
|Si
|-
|Editor WYSISWG
|X
|A veces
|}

''Ejemplo de código''

  import lifetime
   
  for each_day in lifetime.days():
      carpe_diem()

Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie Esto es una nota al pie. y esta es otra nota  Esto es la segunda nota.

{{reflist}}

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lenguajes de marcado ligero

Markdown
Textile
reStructuredText
Texy!
Txt2tags
Marcado Wiki
1. Creole
2. MediaWiki

Cabecera H3

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

Ejemplo de código

import lifetime

for each_day in lifetime.days():
    carpe_diem()

Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie ^[1] y esta es otra nota ^[2]

^ Esto es una nota al pie.
^ Esto es la segunda nota.

Markdown, la mejor opción para crear contenidos web

2011-04-02T20:29:00+02:00

Normalmente cuando se crea contenido en un blog o CMS, como Wordpress, Blogger, Drupal, Joomla, Plone, Typo, etc, se hace a través de un editor visual (WYSIWYG). Algunos editores de este tipo son TinyMCE, CKeditor, NicEdit, WYMEditor, markItUP!, openWYSIWYG, etc.

Yo mismo he empleado varios de ellos durante años, en varias plataformas como Blogger, Wordpress, Joomla, Drupal, etc. Y si, hay que reconocerlo, te hacen la vida muy fácil, sobre todo para aquellos que no quieran preocuparse más que de añadir contenido en su página. E incluso usuarios más avanzados como administradores o diseñadores web, lo suelen emplear por comodidad frente a un área de texto plano. Y si, es cómodo, muy cómodo, a corto plazo. A largo plazo... a largo plazo es cuando empiezas a verle los peros y los problemas, que los tienen, y bastantes. Veamos cuales son esos problemas y la alternativa, que para mi personalmente, es la solución.

Los problemas de los editores WYSIWYG

Los editores visuales están pensados para que de una forma muy fácil, se pueda editar el contenido de forma visualmente atractiva, sin tenerse que andar preocupando del HTML que se genera a partir de él, esto es, no es necesario conocer nada de HTML para usar un editor WYSIWYG. Puedes añadir negritas, cursivas, alinear el texto, cambiar el tamaño, el color, crear tablas, etc, sin conocimiento alguno de HTML o CSS. Se supone que el editor genera HTML valido correctamente por ti. Y aquí es donde empiezan los problemas:

Los editores visuales generalmente crean el formato con CSS embebido dentro del HTMl, es decir mezclando el contenido y el estilo de la página. Algunos incluso te permiten incluir tus propias hojas de estilo para que el contenido se ajuste al estilo actual de tu web.

¿Pero que ocurre cuando al cabo de un tiempo, con decenas o más de artículos generados quieres cambiar el estilo de tú página? Pues dependiendo de como haya realizado el trabajo tu editor WYSIWYG, te puedes encontrar con el desagradable problema de que todo queda desencajado o no se ajusta al estilo actual. Yo me he tenido que enfrentar con este problema en el pasado al actualizar una versión de Drupal y cambiar completamente el tema, y no fue nada cómodo de solucionar, o al importar contenido de un CMS a otro.
Los editores visuales se crearon inicialmente para impresión en papel, no para HTML. Y HTML se emplea en multitud de dispositivos (desde móviles hasta ereaders) y bien empleado proporciona una flexibilidad que se rompe al mezclar la estructura del documento (HTML) con el estilo del mismo (CSS) en el mismo archivo. Así que a la hora de crear versiones para dispositivos móviles, con todas esas etiquetas CSS embebidas, puede ser un verdadero quebradero de cabeza.
Se supone que tienen que generar HTML válido, pero durante mucho tiempo esto no ha sido siempre así, sobre todo si el editor no está bien configurado o tiene algún plug-in que no respeta este tema. Además, generan HTML valido ahora, ¿que pasa en el futuro? Es decir, si quieres pasar contenido antiguo para por ejemplo pasar de HTML 2.0 a HTML 4.0 o incluso 5 y eliminar etiquetas obsoletas y generar HTML que cumpla con el estándar, prepárate, porque te espera una ardua tarea. Por no decir que muchos de estos editores tienen errores en su propio código javascript, lo que lleva a frecuentes actualizaciones de los mismos.
Pueden generar cantidades absurdas de HTML, sobre todo si no están correctamente configurados. Algunos editores (a veces con la configuración por defecto hacen esto, y tienes que ser tú quien lo ajuste para que no ocurra) crean toneladas de <div>,<p> y <span> sin sentido y totalmente superfluos. Cuando no emplean tablas para formatear algunas presentaciones complejas. Y ni que decir tiene de aquellos editores visuales que te dejan pegar contenido desde un procesador de textos como Word, el HTML generado en estos casos, bueno, hay que verlo para creerlo, un absoluto despropósito.
Es incluso factible que un usuario inexperto pueda romper el diseño de una página a través de un editor WYSIWYG, creando párrafos o <div> de forma inadecuada. Incluso al reescribir un texto es posible que se mezclen estilos CSS embebidos antiguos con nuevos, generando unos embrollos inmensos a nivel de HTML. Y ya no digo nada de los que rompen el estilo visual de un tema abusando de colores en las fuentes, tamaños, etc
El contenido que se guarda en la base de datos esta mezclado con las etiquetas HTML y CSS, todo junto, vamos que no se parece en nada a lo que has introducido en tu editor. Todo esto en principio carece de importancia, pero puede suponer hasta el 20% del tamaño de las páginas de tu sitio, espacio absurdamente desperdiciado en tu BDD. De hecho el contenido XHTML se genera por lo normal cada vez que se visualiza la página de forma dinámica. Si te preocupa el rendimiento, tranquilo, los sistemas de cache están ahí para echarte una mano y que te dejes de preocupar por eso.
Distraen la atención, el problema de absolutamente todos los editores visuales, incluidos procesadores de texto, el centrarse en el formato y no en el contenido. Una gran mayoría de usuarios desperdicia un tiempo notable preocupándose por más el aspecto visual del documento, que por el contenido del mismo. Que si esto en negrita, que si mejor con esta fuente, que si mejor con la otra... Se desvía la atención de lo importante, el contenido. Mal amigo de la productividad, se tarda bastante más en general, por esta razón, en generar el mismo contenido en un editor WYSIWYG.
Son bastante poco flexibles, si quieres introducir tu propio HTMl en el contenido (e.g. para tener un control más fino sobre las tablas, yo lo hago en este articulo) puede que te encuentres que lo genera como lo tiene preestablecido, eliminado la estructura que tu quieras darle. Y embeber contenido multimedia o scripts también es frecuentemente un problema, siendo hasta habitual que existan plugins para estos editores para insertar contenidos de sitios como YouTube.
Todos los editores WYSIWYG aumentan el peso por página y disminuyen la velocidad de carga, al necesitar pesado código javascipt que necesita tanto ser descargado como ejecutado por tu navegador. Ya de por si los CMS suelen emplear bastante código javascript, como para encima añadirle un editor visual. Además realizan bastantes llamadas HTTP, ralentizando aún más la velocidad de carga. Ejemplo: tienes un articulo de 80 lineas de texto cuyo contenido XHTML puede pesar tranquilamente de 10 á 20 veces menos que el javascript del editor, ¿no es un poco ridículo?. Aunque muy pocos editores web se preocupan de esto, la verdad, es que hay que pensar que no todo el mundo disfruta de buenas conexiones a la red.
Por último y no menos importante, no cuidan la accesibilidad. El HTML valido que cumpla con los estándares, es esencial para crear páginas con una buena accesibilidad, pensando en aquellos que no lo tienen tan fácil para navegar por nuestros sitios web. Deberían tenerse al menos en cuenta un mínimo de puntos sobre este tema al crear contenidos en la web.

En conclusión, que los editores WYSIWYG pueden no dar problemas hasta que tus necesidades cambian, entonces pueden darte más de un quebradero de cabeza.

Texto plano y Markdown

¿Cual sería entonces la solución para esquivar estos problemas? Texto plano, nada más, que se transforme automáticamente en HTML valido respetando el formato que nosotros queramos darle. Esto existe, y es posible gracias a los lenguajes de marcado ligero, entre los que se encuentra Markdown. Nada mejor que empezar demostrándolo con un ejemplo:

Markdown

Resultado

Documento de ejemplo
====================
Lorem ipsum [dolor sit amet](#mark), consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.
Sed nibh quam, hendrerit _sit amet aliquam_ vel, pulvinar molestie augue.
> Integer cursus, nunc eu ultrices pellentesque, eros leo malesuada turpis, vel convallis neque dolor a nunc. Sed lacus risus, condimentum vitae posuere quis, ultrices pharetra nunc.
Lista numerada (ordenada)
1. Este es el primer elemento
2. Este es el segundo elemento
   * Una lista de puntos anidada
   * Se llama también desordenada
     * Tercer nivel de anidamiento
3. Este es el tercer elemento
![avatar](pictures/avatar.png)
### Cabecera ###
- - -
Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

|   | solo texto | HTML Limpio  |
| -------------- | -- | ------- |
| Markdown       | Si | Si      |
| Editor WYSISWG | X  | A veces |

    :::python
    import lifetime
    
    for each_day in lifetime.days():
        carpe_diem()
Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.
Esto es un texto con nota al pie [^prima] y esta es otra nota [^secunda]

 *[vehicula]: automobila
[^prima]: Esto es una nota al pie.
[^secunda]: Esto es la segunda nota.

Documento de ejemplo

Sed nibh quam, hendrerit sit amet aliquam vel, pulvinar molestie augue.

Lista numerada (ordenada)

Este es el primer elemento
Este es el segundo elemento
- Una lista de puntos anidada
- Se llama también desordenada
  - Tercer nivel de anidamiento
Este es el tercer elemento

Cabecera

Morbi erat augue, feugiat eu pellentesque eget, hendrerit quis lectus. Fusce dignissim pretium nibh sed dignissim. Pellentesque lobortis ante eu dui fermentum vitae blandit risus aliquet.

	solo texto	HTML Limpio
Markdown	Si	Si
Editor WYSISWG	X	A veces

import lifetime

for each_day in lifetime.days():
    carpe_diem()

Suspendisse posuere velit et velit vehicula at scelerisque orci suscipit. Nulla facilisis lorem eu sem viverra varius nec ut felis.

Esto es un texto con nota al pie ¹ y esta es otra nota ²

Esto es una nota al pie. ↩
Esto es la segunda nota. ↩

Es así de sencillo, el texto plano que se escribe en la columna de la izquierda genera el HTML que se puede ver representado en la derecha. Es además HTML valido, sin CSS embebido (exceptuando el código con resaltado de sintaxis, pero esto es necesario y tampoco es generado por Markdown si no por GeSHi anteriormente y ahora por Pygments) y empleando el mínimo necesario, siendo lo más limpio posible. Pero el contenido que se guarda en la base de datos y el que tú editas es el de la izquierda. Este contenido generará HTML valido hoy y mañana, es totalmente independiente del estilo que emplees en tu página y puedes migrarlo de un CMS a otro sin problema alguno. Todo son ventajas, el único inconveniente es que tienes que aprender a usar Markdown, algo que es sumamente sencillo, a la par que incrementa la legibilidad del texto plano.

La legibilidad del texto es uno de los pilares fundamentales de Markdown, tal y como el mismo autor, John Gruber, lo cuenta¹:

No voy ahora, en este articulo, a enseñarte a emplear Markdown, pero tienes una guía de prácticamente todas las posibilidades que te brinda en Markdown & Pygments Lexers Cheat Sheet. Además, si somos así de vagos, podemos emplear también algunos editores visuales que generan y emplean markdown, como markItUP! o el conocido WMD que empleamos en python majibu. Aunque ambos editores solo soportan Markdown estándar, cuando en este sitio también soporto las capacidades adicionales de Markdown Extra.

Todo el contenido de este sitio (exceptuando el automático, como las búsquedas, etiquetas, acerca de, ...) está generado empleando Markdown y todo está en HTML 5 valido. Un ejemplo del HTML que genera Markdown sería el siguiente:

Markdown	HTML
Documento de ejemplo ==================== Lorem ipsum [dolor sit amet](#mark), consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum semper adipiscing leo et blandit. Sed nibh quam, hendrerit _sit amet aliquam_ vel, pulvinar molestie augue.	<h1>Documento de ejemplo</h1> <p>Lorem ipsum <a href="#mark">dolor sit amet</a>, consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum <strong>semper adipiscing leo</strong> et blandit.</p> <p>Sed nibh quam, hendrerit <em>sit amet aliquam</em> vel, pulvinar molestie augue.</p>

Markdown

HTML

Documento de ejemplo
====================

Lorem ipsum [dolor sit amet](#mark), consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum **semper adipiscing leo** et blandit.

Sed nibh quam, hendrerit _sit amet aliquam_ vel, pulvinar molestie augue.

<h1>Documento de ejemplo</h1>

<p>Lorem ipsum <a href="#mark">dolor sit amet</a>, consectetur adipiscing elit. Curabitur eget ante nunc. Pellentesque a tortor ipsum, id rhoncus orci. Quisque leo sapien, rutrum id convallis id, rutrum in ligula. Vestibulum <strong>semper adipiscing leo</strong> et blandit.</p>

<p>Sed nibh quam, hendrerit <em>sit amet aliquam</em> vel, pulvinar molestie augue.</p>

Como se puede ver es el HTMl justo, limpio y cumpliendo estándares, ni más ni menos. Este es un ejemplo muy sencillo, y posiblemente cualquier editor WYSIWYG sea capaz de dar el mismo resultado, el problema aparece con documentos más complejos, con sucesivas re-ediciones del texto y con editores mal configurados. Eso si, lo que se almacena en la BDD con Markdown es texto plano, con los otros editores, el texto, las etiquetas HTML y CSS embebido.

¿Porque Markdown y no otros?

Evidentemente Markdown no es el único lenguaje de marcado ligero, existen otros también conocidos y extendidos como Textile, BBCode, reStructuredText, Texy!, Txt2tags o los empleados en los Wikis como Creole o el de MediaWiki.

En primer lugar Markdown es uno de los que más características soporta, uno de los que más salidas puede generar (no solo HTML, también LaTeX, RTF, PDF, EPUB, ...) y además es probablemente el más extendido y soportado de todos (exceptuando BBCode y los de los Wikis, empleados en sus nichos particulares). Pero también es uno de los más fáciles de emplear (saliendo del formato básico como negritas, etc) y que produce un texto plano más vistoso y legible.

Comparativa

Como no, lo mejor, es ver una comparativa co un ejemplo de el mismo documento y el texto empleado por cada uno de los lenguajes para generarlo. Para ello he creado un articulo aparte para mostrarla.

Comparativa

¿Quién emplea Markdown?

Una de las razones para emplear Markdown es porque es uno de los más extendidos, sobre todo en el mundo de la programación. Por ejemplo, Stack Overflow y todos los sitios de Stack Exchange emplean una variante de Markdown para la entrada de texto. Repositorios de código como GitHub y Bitbucket también lo emplean para ciertas funciones. También lo emplea el sistema de seguimiento de incidencias LightHouse.

Fuera del ámbito de la programación, sitios tan conocidos como Reddit lo emplean. Plataformas para la educación online como Moodle o Podmedics también hacen uso de él. Un Wiki como Instiki permite emplear Markdown. Plataformas de blogs y contenidos como Posterous, Tumblr y Squarespace lo ofrecen como opción. Y seguro que me estoy dejando en el tintero muchos más lugares donde es empleado habitualmente.

Hay que tener en cuenta de que aquí no he hablado de software CMS que lo soporta, eso lo contemplo en el próximo punto, si no más bien de organizaciones/compañías.

Excusas para no emplearlo

La primera que dice todo el mundo, es un incordio usarlo y aprenderlo, la pregunta es: ¿Has intentado emplearlo? Créeme se aprende en nada, sobre la marcha, y una vez que te acostumbras a él, lo elegirás frente a los editores WYSIWYG, casi con toda seguridad. Una vez aprendido no tienes qune separar los dedos de tu teclado, no necesitas para nada el ratón para crear tu contenido. Ganarás mucho tiempo para ti mismo y lo agredeceras, créeme.

La segunda, no puedo usarlo en mi CMS o blog. ¿Seguro? A continuación te detallo las opciones que conozco para publicar contenidos empleando Markdown.

CMS y Blogs:

Por defecto, como opción o nativamente:
- Nesta
- Kohanut
- MovableType
- Typo
Con añadidos:
- Drupal A través de un modulo, Markdown Filter
- Wordpress Hay varios plugins disponibles para emplearlo.
- Django Hay varias formas de soportarlo.
- Plone Se puede habilitar a través de un modulo.
- Blogger A través de algunos proyectos externos, Blogger-markdown-editor
- ExpressionEngine A través de un plugin.
- Joomla A través de una extensión, jMarkdown

Generadores de sitios con contenido estático (HTML):

Plataforma de Blogs con contenido estático (HTML):

Calepin.co es un Pelican hospedado, que lee ficheros markdown desde DropBox

Wiki:

Por defecto, como opción o nativamente:
- Instiki
- ikiwiki
- sputnik
- nanoki
- gitit
Con añadidos:
- MoinMoin con una extensión
- MediaWiki con una extensión
- DokuWiki
- Oddmuse
- PmWiki

Foros:

phpBB A través de un MOD

Conversor Markdown desde/a otros formatos:

Pandoc

Editores de Texto que lo soportan (marcado de sintaxis):

Vim con Vim-Markdown
Emacs con markdown-mode
Gedit con gedit-markdown
Eclipse con el experimental markdown editor
TextMate
SubEthaEdit
Ecto
MarsEdit

Editor Markdown:

Editor Offline para blogs:

Editores Online para probar Markdown:

Dingus por John Gruber
Dingus PHP por Michel Fortin
Markdown Extra + GeShi por Anthony Bush
Dillinger es una aplicación en HTML 5 por Joe McCann
Babelmark para comparar las distintas implementaciones de Markdown
Markdown Editor por John Combe
Showdown
Markdownr

Y si eres desarrollador, tienes disponibles distintas implementaciones de Markdown:

Lenguaje	Implementaciones
Python	Python-markdown
PHP	PHP Markdown y PHP Markdown Extra
Perl	Original y MultiMarkdown
Ruby	BlueCloth, Maruku y Kramdown
C#	Markdown.NET
C	Discount y Peg-Markdown
C++	Cpp-markdown
Java	MarkdownJ
Javascript	Showdown
Lua	markdown.lua
Haskell	Pandoc
Common Lisp	CL-Markdown
Scala	Knockoff y Actuarius

Entonces, habiendo tantas opciones, ¿por qué no lo pruebas?

Y si hay más excusas, pues la verdad, no las conozco, dímelas tú.

The overriding design goal for Markdown’s formatting syntax is to make it as readable as possible. The idea is that a Markdown-formatted document should be publishable as-is, as plain text, without looking like it’s been marked up with tags or formatting instructions. While Markdown’s syntax has been influenced by several existing text-to-HTML filters, the single biggest source of inspiration for Markdown’s syntax is the format of plain text email. fuente ↩

python majibu, preguntas y respuestas sobre python

2011-03-30T00:32:00+02:00

Aunque ya hace casi dos meses que está funcionando, no es hasta ahora cuando he tenido un momento para escribir sobre este nuevo proyecto que he iniciado. Este surgió a partir de otro proyecto anterior que resulto ser un fracaso, deaparatos PyR, un sitio de Q&A (preguntas y respuestas) sobre gadgets y aparatos de electrónica que se apoyaba en deaparatos.com mi anterior página sobre la misma temática. Una vez realizado el esfuerzo de traducción al español y adaptación del tema, se me ocurrió que podía aprovechar ese trabajo ya realizado para una aventura bastante más práctica. Así el día 3 de febrero sugerí en la lista de Python en español, donde se agrupa una buena parte de la comunidad hispana de Python, el poder aplicar este mismo formato a un sitio de Q&A sobre Python. La idea tuvo una buena acogida, y así 11 horas después, nacía Python majibu, mi pequeña contribución a la comunidad Python en español. Y como decía en ese correo:

Origen del formato Q&A

Este sitio se monta sobre la plataforma OSQA (Open Source Questions & Answers) que la gente de DZone creo a partir del extinto proyecto chino CNProg de Mike Chen and Sailing Cai. Estos dos proyectos eran un clon del original formato empleado por StackOverflow, funcionando sobre Django (ergo Python).

Stack Overflow es el sitio que ha conseguido revolucionar el formato de Preguntas y Respuestas y causado un gran impacto mediático en la red, sobre todo en el mundo anglosajón. Esto formato lo crearon Joel Sposky y Jeff Atwwood para su red de sitios StackExchange (hoy ya constituida como empresa) y que ha dado lugar a sitios tan exitosos en el mundo anglosajón como el propio Stack Overflow, Server Fault, Super User, Ask Ubuntu, How to Geek, etc. Un formato que se creo para StackOverflow, por programadores y para programadores, centrado únicamente en aspectos técnicos de la programación informática. Y su éxito ha sido tan brutal que se ha extendido a multitud de temáticas que no paran de crecer día a día. Es el formato del futuro inmediato, ya lo es ahora mismo del presente para ciertas temáticas y es sin duda el formato que podría enterrar a los clásicos, veteranos y populares foros. Y no es ninguna broma, la red de sitios de preguntas y respuestas StackExchange arroja unas cifras de 16.6 millones de usuarios únicos mensuales¹ y 72,8 millones de paginas vistas al mes y todo esto en poco más de dos años.

Aunque cronológicamente, primero fueron los foros, luego Yahoo Answers, sitios como todoexpertos, luego el casi difunto servicio de Ask, luego propuestas como Wolfram|Alpha e IBM Jeopardy², más tarde y centrado en un perfil de gente muy determinado y elitista: Quora Y por fin, democratizando el formato y el conocimiento para todos los públicos: la red StackExchange. De ahí surge luego OSQA como clon sobre Django de Stack Overflow, y el futuro Qato por parte de la misma gente de DZone, pero de pago y centrado en perfiles corporativos y grandes sitios de Q&A. Incluso la gran red social, Facebook, se ha sumado, creando su propia propuesta del formato de Preguntas y Respuestas.

Y en español han surgido también varias alternativas. Desde la red de Shapado, otro clon de Stack Overflow creado en Ruby, a sitios como ChaxPert, Respuestas para todo y otros sitios en español montados también sobre OSQA como son Trabber y Cientifi.net

Ventajas del formato Q&A

Básicamente un sitio de Q&A, es una web de preguntas y respuestas dirigida por sus propios usuarios, que son quienes hacen las preguntas, las responden compartiendo su conocimiento y moderan la comunidad. Es un formato basado en el karma de sus usuarios y ellos son los protagonistas absolutos.

La ventaja principal es que a través de la participación de los usuarios las respuestas más acertadas y valiosas ganan más visibilidad que las menos ajustadas a la solución. Lo que es una gran ventaja para los que se vuelvan a plantear esa misma pregunta, pues al leerla encuentran la solución más idónea antes, sin verse obligados a navegar entre un mar de respuestas, o incluso off-topics, como es tan frecuente en en los habituales foros. A tal extremo llega esto que si uno realiza preguntas sobre programación en inglés en un buscador como Google, la probabilidad de que la respuesta esté en Stack Overflow y entre los primeros resultados del buscador es muy elevada.

Por lo tanto es un formato bastante más eficaz y dinámico que el de los foros y el sistema de karma ayuda a crear una comunidad de gente muy competente. Además el que la propia comunidad modere el sitio (gracias al sistema de karma) causa que apenas exista la lacra del spam, que en estos sitios brilla por su ausencia, así como la inexistencia de trolls que con este formato tienen muy pocas posibilidades de causar problemas. Pero lo fundamental es que consigue que las personas se animen a preguntar y a compartir sus conocimientos con mayor naturalidad que con los foros y con muchos mejores resultados.

Python majibu

Yo echaba de menos algo como Stack Overflow en español, aunque no tengo problemas con el inglés y consulto habitualmente los sitios de StackExchange, era una pena que la comunidad en español no tuviera un sitio como este. Como abarcar un campo tan amplio como el de la programación se me antojaba demasiado, que menos que hacer mi humilde aportación a mi lenguaje de programación favorito, Python. Aunque yo solo puse la base, el sitio lo crean sus usuarios, python majibu no sería nada sin la gente que forma la comunidad de Python en español. Ellos son los que aportan el conocimiento, la verdadera esencia del sitio y los que decidirán el éxito o no del proyecto y su rumbo.

Para personalizar el sitio, con respecto a la instalación por defecto de OSQA, completé la traducción que otros habían iniciado anteriormente al Español y cree un nuevo tema para majibu. Este trabajo está disponible en mi repositorio para todo aquel que quiera aprovecharlo.

Adelante, usadlo si queréis, resolver vuestras dudas sobre Python y ayudar a resolver las de los demás... el sitio es todo vuestro, yo solamente soy el intermediario necesario para que sea posible. Para utilizar este nuevo sitio no es necesario crear una cuenta nueva, se puede entrar usando tu cuenta de Facebook o Twitter. También puedes usar cualquier otro servicio que soporte OpenID como Google, Yahoo, myOpenID, Blogger, Wordpress, Flickr, etc.

A Diciembre de 2010 ↩
Propuestas mucho más complejas, automatizadas y más pruebas de concepto que alternativas reales en el presente, pero un claro indicio de lo que nos espera en el futuro. ↩

Sincronizar una carpeta local y una remota a través de FTP: lftp-mirror

2010-12-19T14:58:00+01:00

A veces tenemos la necesidad de subir (o bajar) contenido a un servidor y posteriormente tener actualizados los cambios que se produzcan en uno (o ambos) de los lados. Es decir tener sincronizados el directorio remoto y el local. Esto es relativamente fácil cuanto tenemos acceso via consola y ssh al servidor y podemos utilizar programas tan potentes como rsync. ¿Pero que ocurre cuando el único método del que disponemos para intercambiar ficheros con el servidor es a través del protocolo FTP, como ocurre con muchos servidores web?

Bien, en ese caso, tenemos un pequeño problema. El protocolo FTP aunque perfectamente valido para las funciones para las que fue originalmente creado, la transferencia de archivos, no contempla este caso. La solución manual y menos efectiva es volver a transferir todos los archivos cada vez que se produce un cambio, solución nada recomendable a nada que el tamaño de estos empiece a ser superior a decenas de Megabytes. También podríamos ir comprobando manualmente que ficheros han cambiado y transferir únicamente estos, algo también muy poco recomendable si el número de archivos es elevado. Afortunadamente algunos clientes gráficos de FTP nos permiten comprobar que ficheros son distintos en uno y otro lado y luego transferir únicamente estos, lo cual ya es un método bastante más efectivo y adecuado. Aunque si se trata de directorios con muchos archivos y una estructura jerárquica compleja (muchos directorios y subdirectorios) el proceso es bastante lento pues ha de ir comprobando en un lado y en el otro las diferencias entre los archivos (fecha, tamaño y atributos únicamente) recorriendolos todos. ¿Pero que ocurre si queremos realizar esta operación de forma periódica y automática? entonces esta solución tampoco es valida, pues necesitaríamos un programa de línea de comandos o un script para realizarlo.

Por suerte para nosotros, esta solución también está disponible a través de varios programas y scripts para consola, entre los cuales el mejor es lftp de Alexander V. Lukyanov. Este fantástico programa es una navaja suiza para todo aquello que necesitemos hacer a través de FTP, siendo uno de los mejores clientes FTP, si no el mejor, que existen. Y una de las innumerables posibilidades que ofrece es precisamente la de sincronizar dos directorios con la opción mirror (espejar). De esta manera podemos mantener perfectamente sincronizados dos directorios de forma automática. Nos permite hacer la sincronización en ambas direcciones, remoto → local y local → remoto.

Como ya he mencionado es muy potente y repleto de opciones y permite muchas más operaciones más allá de la sincronización entre directorios. Por este motivo he creado un script en Python que empleando lftp, se centra únicamente en la sincronización entre directorios a través de FTP y añade algunas nuevas funcionalidades, lftp-mirror.

¿Que ventajas aporta este script?

Proporciona un log detallado y legible que graba en un fichero en disco y que puede ser enviado por correo electrónico a una o varias direcciones empleando el servidor de correo local o uno externo.
Permite crear una copia comprimida por día de la semana del directorio local sincronizado. Esto nos permite tener el directorio actualizado y una copia de seguridad por cada uno de los últimos 7 días, para poder revertir algún cambio o borrado accidental.
Se centra únicamente en la sincronización (mirror) entre directorios, obviando las otras opciones que nos ofrece lftp
Nos proporciona (en el log) el tamaño del espacio ocupado en el disco duro por el directorio local y las copias de seguridad.
Permite tres modos de ejecución distintos, lo que lo convierte en muy versátil:
- Como tarea programada. En este modo los parámetros de la sincronización se incluyen directamente dentro del script y solo es necesario programar su ejecución para automatizar el proceso. Es ideal para la sincronización periódica de un único directorio/servidor FTP
- Interactivo. En este modo los parámetros se introducen directamente como argumentos en la línea de comandos. Es ideal para ejecutar una sincronización puntual manual
- Importando los parámetros desde un fichero de configuración. Este modo es similar al primero, con la diferencia de que en este caso los parámetros los tomamos de un fichero de configuración externo. Este fichero que podemos crear nosotros mismos (se sirve uno de ejemplo) nos permite establecer múltiples operaciones de sincronización que se ejecutaran de manera secuencial una detrás de otra.
En sistemas operativos que lo soporten nos muestra notificaciones emergentes a través de la librería libnotify de la ejecución del script y su correcta finalización. Por ejemplo, a través de las notificaciones emergentes de Ubuntu. Muy útil para conocer cuando se está ejecutando una tarea programada sin salida por consola.
Si empleamos los modos de ejecución no interactivos, emplea base64 para una mínima protección de la contraseñas de acceso a los servidores FTP y evitar almacenarlas las mismas en texto claro. No es una fuerte medida de seguridad, pero es lo mínimo que deberíamos tener en cuenta.

¿Para que nos puede servir este script?

Vamos a ver un ejemplo de lo más común, las copias de seguridad de una página web. En muchos hosting compartidos la única posibilidad de transferir archivos con el servidor es a través de una cuenta FTP. Empleando este script, podemos crear un directorio en local donde haremos las copias de seguridad de los ficheros de la web y luego sincronizarlo automáticamente todos los días, descargando únicamente los ficheros que han cambiado. Con esto tendremos no solo el directorio actualizado diariamente, si no que además dispondremos de una copia de seguridad por cada uno de los siete días anteriores para poder corregir cualquier problema ocurrido entre esas fechas. Configurar algo así es realmente sencillo, únicamente tendríamos que cambiar los valores incorporados dentro del script por los que necesitamos y luego programar su ejecución diaria con cron.

Para una introducción más detallada, instrucciones de ejecución, control de versiones y enlaces para la descarga, acudir al repositorio del script

Un extracto del código de lftp-mirror.py:

def mirror(args, log):
    """Mirror the directories."""

    user = '' if args.anonymous else ' '.join(args.login)
    local, remote = os.path.normpath(args.local), os.path.normpath(args.remote)
    port = '-p {0}'.format(args.port) if args.port else ''
    include = ' --include-glob {0}'.format(args.inc_glob) if args.inc_glob else ''
    exclude = ' --exclude-glob {0}'.format(args.exc_glob) if args.exc_glob else ''

    url = 'http://code.joedicastro.com/lftp-mirror'
    msg = 'Connected to {1} as {2}{0}'.format(os.linesep, args.site, 'anonymous'
                                              if args.anonymous
                                              else args.login[0])
    msg += 'Mirror {0} to {1}'.format(local if args.reverse else remote,
                                      remote if args.reverse else local)
    log.header(url, msg)
    log.time('Start time')
    notify('Mirroring with {0}...'.format(args.site), 'sync')

    if not os.path.exists(local):
        os.mkdir(local)
        log.list('Created new directory', local)
    os.chdir(os.path.join(local, os.pardir))

    # create the script file to import with lftp
    scp_args = ('-vvv' + args.erase + args.newer + args.parallel + args.reverse
                + args.del_first + args.depth_first + args.no_empty_dir +
                args.no_recursion + args.dry_run + args.use_cache +
                args.del_source + args.missing + args.existing + args.loop +
                args.size + args.time + args.no_perms + args.no_umask +
                args.no_symlinks + args.suid + args.chown + args.dereference +
                exclude + include)

    with open('ftpscript', 'w') as script:
        lines = ('open {0}ftp://{1} {2}'.format(args.secure, args.site, port),
                 'user {0}'.format(user),
                 'mirror {0} {1} {2}'.format(scp_args,
                                             local if args.reverse else remote,
                                             remote if args.reverse else local),
                'exit')
        script.write(os.linesep.join(lines))

    # mirror
    cmd = ['lftp', '-d', '-f', script.name]
    sync = Popen(cmd, stdout=PIPE, stderr={True:STDOUT, False:None}[args.quiet])
    # end mirroring

    log.list('lftp output', ''.join(sync.stdout.readlines()))

    # compress the dir and create a .gz file with date
    if not args.reverse and not args.no_compress:
        notify('Compressing folder...', 'info')
        log.list('Rotate compressed copies', compress(local))
    # end compress

    gz_size = sum([get_size(gz) for gz in glob.glob('{0}*.gz'.format(local))])
    log_size = get_size(log.filename) if os.path.exists(log.filename) else 0
    local_size = get_size(local)
    size = best_unit_size(local_size + gz_size + log_size)
    log.block('Disk space used', '{0:>76.2f} {1}'.format(size['s'], size['u']))
    log.time('End Time')
    log.free(os.linesep * 2)
    log.write(True)

    os.remove(script.name)

Para obtener el código completo, ir al fichero fuente.

Combatir el spam en Drupal

2010-10-14T01:42:00+02:00

Articulo publicado originalmente en el antiguo sitio deaparatos.com

En esta gráfica se puede observar la disminución a lo largo del tiempo de los ataques de spam a este sitio, deaparatos.com, que funciona sobre Drupal. Esto se ha conseguido gracias a una doble estrategia:

emplear uno de los mejores módulos antispam existentes para Drupal, Mollom
emplear un script en python de elaboración propia, ban_drupal_spammers.py

Esta doble estrategia no solo ha conseguido una más que notable reducción de la incidencia del molesto spam en este sitio, de casi un 70%, si no que además ha conseguido una más que notable reducción del ancho de banda consumido por los spammers, como se puede observar en la siguiente tabla:

Estadísticas de Trafico generado por ataques de spam en deaparatos.com

Estrategia	Días	Ataques	Trafico (GB)	Media pagina (KB)	Trafico mes (MB)
Mollom	359	48741	7,116	146,000	602,927
Mollom + script	359	358666	0,016	0,046	1,389
Total	359	407407	7,133	17,507	604,316

Si solo hubiera empleado el modulo Mollom, sin emplear mi script

Trafico spam	Calculo	Trafico (GB)	Ahorro (GB)
Trafico total	(358666 * (146,000 – 0,046) KB) + 7,133 GB =	59,481	52,349
Trafico mensual	((59,465 GB * 365) / 359) / 12) MB =	5,040	4,435

Como podemos ver en las cifras mostradas de esta tabla, se ha conseguido en un periodo de aproximadamente un año reducir el ancho de banda consumido por los ataques de spam en más de 52 Gigabytes!, una autentica barbaridad de tráfico que de otro modo se hubiera malgastado. Estamos hablando de un ahorro de consumo de tráfico de casi 4,5 Gigabytes al mes!!! Un ahorro de ancho de banda mensual que en un hosting compartido puede tranquilamente suponer el cambio de un plan de hosting a otro, simplemente basta con que los molestos spammers pongan tu sitio web en su punto de mira. Y ha de tenerse en cuenta una cosa, que este trafico mensual hubiera sido muy superior si esta doble estrategia no hubiera conseguido reducir el numero de spammers en un 69.25%, no quiero ni pensar en las cifras que hubieran resultado...

Para que nos hagamos una idea del ahorro de ancho de banda que ha supuesto el emplear mi script python, en el siguiente gráfico podemos ver la diferencia entre emplear solo Mollom y emplear Mollom combinado con ban_drupal_spammers.py

El gráfico es meridianamente claro, como podemos ver, por cada 1% de ataques que son rechazados por ban_drupal_spammers.py y no por Mollom, ahorramos un 1% de ancho de banda, tanto en el peso por página como en el tráfico total. Como podemos ver, hemos ahorrado un total de un 88% de ancho de banda del trafico que sería generado por los ataques de spam en deaparatos.com

Después de comprobar la eficacia de esta doble estrategia durante más de un año (las estadísticas se interrumpen antes por el cambio de hosting) voy a explicaros el porqué y el como he llegado a ella, a continuación. También se puede ver el script que ha marcado la diferencia de tráfico.

El spam en internet

El spam es una de las lacras más tediosas y difíciles de combatir en Internet, por no mencionar las tareas delictivas que se apoyan en él. Después de 15 años combatiendo el spam en el correo electrónico, el problema aún está lejos de solucionarse, si bien es cierto que con una adecuada configuración de las herramientas de correo, se ha convertido en una molestia trivial para el usuario final. Pero para los servidores de correo y el tráfico de internet sigue siendo un problema de dimensiones colosales, la lucha contra el mismo se ha convertido una tarea titánica en la que se invierten ingentes sumas de dinero todos los años. De hecho gran parte del tráfico de toda internet se debe al spam (hay quien arroja cifras del 80%, e incluso superiores al 90%), lo que ha acarreado un costosísimo sobredimensionamiento en el equipamiento de proveedores de internet y servidores.

Como antes comentaba, lejos de una solución definitiva (en gran medida depende de un tipo muy común de usuario final con escasa cultura informática), esta lacra se expandió hace unos años a hilos en foros, a comentarios en blogs, redes sociales, irc,... es decir, se ha expandido por toda la red. La explosión de la llamada web 2.0 no ha incrementado si no este problema, multiplicándolo. Y he aquí como un problema que afectaba a los usuarios de email y a los proveedores de internet, se ha convertido también en un gran problema para los webmasters. Todo aquel que gestione un sitio web, ha tenido que enfrentarse antes o después con este maldito problema. Un problema que no solo se traduce en cientos o miles de detestables mensajes de spam, que se han de combatir de uno u de otro modo (algunos o bien se rinden o bien tienen abandonados sus sitios y se convierten en auténticos cementerios de spam), si no que además se traduce en un serio problema para el trafico de una web. El número de solicitudes que producen los ataques de spam puede llegar a ser tan elevado, que congestione totalmente ya no solo la página, si no el servidor cuando se trate de un hosting compartido, convirtiéndose casi de facto en un ataque DoS en toda regla. Aún sin llegar a este indeseable extremo, el incremento del tráfico en el sitio debido al spam puede llegar a suponer un porcentaje muy importante del ancho de banda contratado (incluso más del 50% con contramedidas ineficientes), con los consiguientes perjuicios económicos que suponen al webmaster. Los spammers siempre han ido por delante de las contra-medidas, y la actual situación, con extensas botnets a su disposición y con el cloud computing (se ha detectado el año pasado la primera botnet que empleaba los servicios de Amazon EC2) , nos ha llevado a un combate continuo en las que tienen todas las de ganar a medio plazo... y observo esto con cierta tristeza, por que entiendo que la solución final pasa necesariamente por la educación del usuario final, haciéndole inmune a los -en gran medida patéticos, infantiles, ridículos y chapuceros- reclamos del spam. Y esto último desgraciadamente dista mucho de acercarse a una situación ideal. También cabe mencionar que el spam también perjudica al posicionamiento de una web, a su prestigio, a su funcionalidad, a su aspecto, etc.

deaparatos.com y el spam

Y deaparatos no está exento de esta amenaza, de hecho se había convertido en un serio problema en el 2009. Este sitio está gestionado con Drupal, y después de probar con distintos módulos y métodos, unos más frustrantes que otros, ninguno solucionaba por completo el problema, ni me satisfacía como solución. Al final, combinando el módulo más idóneo para combatir esta plaga (idóneo por resultados y por comportamiento) con un script de factura propia en Python, he logrado, no acabar con todo el spam (se me antoja tarea cuasi imposible), pero si minimizar sus efectos a un nivel muchísimo más que aceptable. Y minimizar los efectos tanto a la hora de impedir/eliminar los comentarios spam, como de reducir el abultado tráfico que estos ataques consumían. ¿Por qué un script en Python? bueno buscaba algo rápido, un prototipo para probar la solución que tenia en la cabeza y porque estoy "enamorado" de este lenguaje de programación. Quizás si veo que merece la pena, me plantee migrarlo a PHP y convertirlo en un módulo de Drupal, o bien modifique el modulo oficial que estoy empleando para mitigar el spam y le incorpore el código que empleo ahora. Bueno, veamos como he llevado a cabo esta solución y porqué.

Generalmente los métodos para combatir el spam se centran en:

medidas activas: análisis heurísticos, filtros estadísticos (bayesianos), diferenciación de bots/humanos (captchas), filtros por host/email, mediante cookies, timestamps, filtros por user-agent, ...
medidas pasivas: ofuscar direcciones de correo, moderación de comentarios, enlaces nofollow, permisos de publicación, políticas de contraseñas, campos ocultos mediante css/javascript, cerrar los comentarios de un post pasado un tiempo, ...

De entrada tenía, y tengo, algo muy claro, no voy a emplear ninguno de estos tres métodos habituales: captchas, moderación de comentarios y requerir registro para enviar comentarios. Y es una decisión inamovible, no pienso claudicar de ningún modo en este sentido. Son métodos que o bien me harían perder un tiempo del que ni dispongo, ni estoy dispuesto a perder, o bien suponen un incordio que me personalmente me incomodan mucho cuando me los encuentro en otros sitios y por los que no quiero hacer pasar a mis lectores. Esto evidentemente deja fuera algunas de las medidas más efectivas para combatir el spam, pero son medidas en las que el usuario o el webmaster siempre pierden, de un modo u otro, y no estoy dispuesto a permitir que los spammers condicionen en ningún modo el compartimiento de este sitio. Aunque suene contradictorio con lo que acabo de decir, el método que voy a comentar aquí, y que empleo actualmente, emplea en alguna medida el uso de captchas, aunque de modo tan limitado, que afecta a menos del 0,5% de los comentarios enviados. Digamos que lo acepto como una razonable excepción a la regla. Si empleo en cierta medida algunos de los otros métodos.

You need to upgrade your Flash Player

En este mapa podemos ver el país de origen de los ataques de spam contra deaparatos.com

Drupal y el spam

Con que armas contamos en Drupal para combatir el spam? Por un lado tenemos el clásico modulo Spam, que emplee en este mismo sitio durante más de dos años, y que su mayor ventaja es contar con un filtro Bayesiano. Este módulo es usado actualmente en unos 4.893 sitios ¹ con Drupal. Durante mucho tiempo funcionó perfectamente, de vez en cuando se colaba algún comentario spam, pero era cuestión de reportarselo al modulo y el iba aprendiendo, así como podíamos crear nuestros propios filtros personalizados. El problema comenzó cuando los que se colaban ya eran unos 20 spam diarios y aumentando, y entonces ya no era viable, ni cómodo, perder tanto tiempo para que el filtro bayesiano aprendiera a combatir unos ataques que eran cada vez más sofisticados. Así que tocaba mirar otra alternativa de entre alguna de las disponibles:

Captcha, uno de los más usados en Drupal (80.286 sitios), y uno de los métodos más empleados en la red. Es la clásica opción donde mediante una pregunta al usuario se intenta diferenciar entre humano y maquina. Los captchas pueden ser de varios tipos, desde cálculos matemáticos sencillos hasta gráficos donde se encuentran unos caracteres ofuscados y que el usuario debe introducir. Hay varios módulos que lo complementan, aportando distintos tipos de captchas, donde reCaptcha es uno de los más empleados (16.684).
Akismet, todo un clásico, basado en el servicio homónimo, Akismet, que creara en su día Wordpress y que hoy es sostenido por Automattic, empresa donde trabajan la mayoría de los desarrolladores oficiales de Wordpress. Es uno de los métodos más difundidos en la red, en parte por venir de la mano de la empresa más emblemática de los blogs. Esta implementación del servicio akismet es ya un tanto antigua (ya no tiene soporte) y hay un modulo más reciente que lo supera y aporta más funcionalidades, Antispam, también en esta lista. Es usado actualmente por solo 947 sitios.
Spamicide, se basa en la premisa de que la mayoría de los ataques spam se producen con bots que acceden a la página con navegadores en modo texto (scripts en realidad), por lo tanto ni hacen uso de css, ni de javascript. Aprovechando esta circunstancia, crean un campo de formulario que es ocultado con css, con lo cual el usuario normal no lo ve, pero si el bot, que si lo rellena con texto, queda descartado. Pero los spammers aprenden muy rapido, así que la medida no es muy efectiva. Además últimamente empiezan a aparecer personas dedicadas a introducir comentarios spam a mano (de ahí vienen muchos de esos comentarios hoygan absurdos que no parecen tener mucho sentido) y que cobraran una miseria en países subdesarrollados, en parte para saltarse los captcha. Por eso su efectividad es muy dudosa. Aunque si puede ser usado combinado con otros módulos spam, para reforzar su eficacia. Es muy poco usado, apenas 377 sitios lo emplean.
Antispam, uno de los mejores módulos antispam para drupal. Con el se puede usar algunos de los mejores servicios antispam externos que hay en la red: Akismet, Typepad y Defensio. Con él podemos abrir una cuenta en uno de estos servicios y configurar el módulo para emplearlo. Su eficacia es muy elevada, ya que son algunas de los mejores armas disponibles contra el spam. El funcionamiento básico es consultar la base de datos de alguno de estos servicios, muy completas, para comprobar si el comentario u el posteador son probable spam, y bloquearlo en caso de que la probabilidad sea muy elevada. En caso de duda, aparecerá un captcha para descartar bots. Tiene unas gráficas estadísticas muy útiles para comprobar la evolución del problema en nuestro sitio. No es demasiado empleado, estando instalado en unos 1.718 sitios.
Bad Behavior, otro viejo conocido de las medidas antispam. Este se basa en parte en un análisis heurístico de las peticiones HTTP del bot y comparándolo con las bases de datos que poseen de spambots conocidos. Este hace uso también de las base de datos del Proyecto Honey Pot, para reforzar la identificación de spammers. Es bastante eficiente, pero el problema está en que van por detrás siempre de los spammers y a veces se les cuela algún que otro comentario spam. Básicamente porque se basa en que uno reporte los spammers que aún no están en sus bases de datos, y hasta que alguien reporta a un spammer, este puede habernos colado unos cuantos mensajes. Es empleado en unos 918 sitios drupal.
http:BL, ese se basa enteramente en el Proyecto Honey Pot. Usa sus bases de datos (DNS blacklist) para prevenir comentarios spam y recolectores de direcciones email. Es eficiente en la misma medida que el anterior, depende de su base de datos, que no es tan completa como las de los servicios que soporta el modulo Antispam. Una de las virtudes de este modulo es que bloquea las solicitudes de pagina de aquellas Ips que están en su lista negra, con el consiguiente beneficio que esto reporta para el trafico de nuestro sitio. Permite también el uso de whitelists y greylists. Podría ser uno de los mejores módulos antispam para Drupal si no se colaran más comentarios spam de lo deseable. Actualmente solo443 sitios emplean este modulo.
PHPIDS, esta emplea una aproximación al problema diferente. Emplea un sistema de detección de intrusos desarrollado y mantenido por PHPIDS. Este no solo detecta ataques de spam, si no que también otro tipo de ataques maliciosos al sitio, como XSS (cross site scripting), inyecciones sql, DoS, etc. El problema es que arroja demasiados falsos positivos y hemos de ir afinando la detección poco a poco, lo cual puede llegar a ser bastante tedioso. Se puede usar conjuntamente con otros módulos antispam, pero normalmente este bloqueará el ataque antes de que el otro se percate. Lo malo, claro, es que hasta que no esté completamente afinado, a los usuarios les puede dar mucho la lata ante comentarios completamente inocuos. También puede llegar a generar unos logs muy extensos que pueden incrementar bastante nuestra base de datos. Puede ser muy útil para aquellos sitios en los que los ataques van más allá del simple spam. Tampoco es muy empleado, solo 361 sitios lo tienen implantado.
Mollom, uno de los últimos en llegar, pero lo ha hecho arrasando, en dos años ha conseguido que ya sea empleado en 23.983 sitios drupal. Esto se debe en parte a que uno de los co-autores es el creador de Drupal, Dries Buytaert. Mollom es un servicio web en la misma linea que Askimet o Defensio, con una base de datos de usuarios en la que aparte de spammers, se registran reputaciones de usuario en función de parámetros como comentarios ofensivos, comentarios de "baja-calidad" (hoygans), comentarios off-topic, etc según como nosotros lo reportemos a Mollom. Es decir que nos ayuda también a mejorar la calidad de nuestro sitio filtrando también a usuarios con baja reputación en función de los parametros que nosotros marquemos. Esto desde luego es un punto a favor del servicio, que nos permite matar dos pajaros de un tiro. El servicio analiza el texto del mensaje, y si es spam, lo bloquea y en caso de dudas mostrara un captcha como el de la imagen (menos del 2% de las ocasiones). Además todo el código es opensource, tanto el del modulo como el de la API de Mollom y hay disponibles módulos para otros gestores de contenidos como Wordpress, Joomla o Radiant y librerías para múltiples lenguajes (Java, PHP, Ruby, Python, Perl, .Net, ...).

Después de analizar las posibilidades y probar unos cuantos módulos (Antispam, Bad Behavior, http:BL, PHPIDS y Mollom) llegué a valorar que las dos mejores soluciones en mi caso eran Antispam Y Mollom. Aunque PHPIDS y http:BL tenían algunas características únicas que echaba de menos en ellos. Después de probar durante unas semanas tanto Antispam como Mollom, observe que el indice de fallos de Mollom era mucho menor y además era más transparente al usuario, mostrando el captcha en menos ocasiones. Si, Captcha es la opción más socorrida por la mayoría de los usuarios de Drupal, en cuanto que es la que menos molesta al webmaster, claro, pero le traspasa la molestia al usuario. Yo odio directamente los captcha, no los soporto, y he pasado de utilizar alguna web por ellos. Mollom tiene la ventaja de reducir esta molestia a la minima expresión, por lo que el 98% de los usuarios de la web ni siquiera se darán cuenta de que en ella funciona un sistema antispam, que es lo que buscaba desde el principio, un servicio efectivo y transparente.

Mollom era pues, la opción elegida y la que está funcionando en este sitio desde entonces.

Ejemplo de captcha generado por Mollom

La solución definitiva, Mollom + ban_drupal_spammers.py

Aunque Mollom funciona de manera muy efectiva, bloqueando aprox. el 99,98% (en deaparatos.com) de los mensajes spam, esto no impide que los atacantes sigan intentando una y otra vez colar su spam en el sitio. Esto nos lleva a que las páginas se cargan una y otra vez, consumiendo ancho de banda, ya que Mollom actúa a posteriori, cuando se envía el comentario, no antes de cargar la página, lo que es el funcionamiento normal de estos sistemas antispam. Y además los spammers tienen cierta inclinación a intentar introducir el spam en las paginas más populares, las que suelen tener más comentarios y por lo tanto de mayor peso por lo general. Basta con decir que el ancho de banda medio generado por cada uno de estos ataques en este sitio ha sido de 146Kb.

Y es en este aspecto donde echaba de menos una de las características de http:BL, bloquear el acceso al sitio a los que están en su lista negra. Empecé entonces a darle vueltas a la manera de implementar esta característica en mi sitio, pero pronto me di cuenta de dos cosas:

No quería hacer una consulta a projecthoneypot.org cada vez que alguien accediera al sitio, por evidentes mermas en el rendimiento del sitio.
No quería tampoco tener una lista negra local que se alimentara periódicamente de projecthoneypot.org, porque no quería tener que comprobar miles de ips que probablemente nunca accederían a mi sitio.

La solución entonces pasaba por bloquear solo a los que ya hubieran ejecutado un ataque de spam contra el sitio y que hubieran sido bloqueados al menos una vez por Mollom, de modo que en los sucesivos ataques fueran rechazados antes siquiera de cargar la página.

Hay una forma de hacer esto de forma manual en Drupal, simplemente hay que añadir las ips de los spammers a través de las reglas de acceso en el menú de Administración. Claro que el método es evidentemente tedioso y aparatoso, comprobar las ips atacantes e ir añadiéndolas una por una a través del formulario. Tenía que hacerse de una manera automatizada.

La primera idea y más evidente era modificar el modulo Mollom para lograr esto, pero no me gusta PHP y procuro evitarlo, además quería un prototipo rápido para evaluar la eficacia de la solución y su repercusión en el ancho de banda, así que todo empezó con un sencillo script en python. Pronto me di cuenta de que Mollom registraba las ips de todos los atacantes que bloqueaba en el registro de eventos de Drupal (la tabla watchdog del modulo opcional Database logging), y que alguna de ellas tenía hasta 30 entradas diferentes en el registro. Y como Drupal incorpora el método que citaba antes para banear IPs, lo único necesario era añadir estas IPs a la tabla access.

Este es un ejemplo de la pàgina que se encontraria un atacante de spam bloqueado a través de la tabla access en Drupal

Ahora bien, si añadimos automáticamente estas IPs, llegara un momento en que tendremos varias miles de ellas, y el rendimiento de la página se vera afectado, al tener que comprobar todas estas ips cada vez que alguien accede a la página. Además hay que tener en cuenta que algunas de estas IPs tendrán como origen a un usuario que teniendo el ordenador o router infectado por un rootkit/troyano, pertenezca a una Botnet sin saberlo. Es posible que estos usuarios acaben limpiando de malware su equipo y en un momento determinado quieran acceder legítimamente al sitio, por lo que no deberían estar bloqueados de por vida. Esto lo solucioné en el script rotando las IPs al llegar a umbral determinado, marcado por el número máximo de las IPs que deseemos almacenar en esta tabla. Al llegar a este número máximo, se borra un porcentaje de IPs, eligiendo siempre a las más antiguas. En estos momentos, en función del rendimiento y tiempo que quiero que permanezcan en la tabla, tengo este valor establecido en unas 2000 IPs. Para controlar la fecha en que fueron introducidas cada una de las ips en la tabla, modifico la tabla access, añadiéndole un campo timestamp.

Como se pudo ver al principio del articulo, la efectividad del script es muy elevada y a día de hoy sigo con este método, con un script que ha evolucionado varias veces desde entonces y que se adapta perfectamente a mis necesidades. Los picos que se pueden ver en el primer gráfico del spam bloqueado por el modulo Mollom, se deben precisamente a los breves periodos de tiempo en los que por una u otra razón el script no estaba funcionando.

El porqué del fantástico ahorro de ancho de banda se puede explicar con la anterior imagen, que es un ejemplo de la página que se encontraría un atacante bloqueado por ban_drupal_spammers.py. Esta página tiene un peso ridículo de entre 33 y 39 bytes, del orden de unas 4000 veces menos que el peso medio de 146 Kilobytes por página del trafico generado por los spammers.

Este script se puede ejecutar en remoto, para hostings compartidos que no pueden correr scripts en python pero si permiten acceso remoto a la base de datos en MySQL, como mi anterior hosting (quede muy satisfecho). Pero también puede ser ejecutado de manera local, en hosting compartidos (que soporten python), en VPS y en servidores dedicados. No muchos hostings compartidos permiten la ejecución de scripts en python, ni siquiera ssh o acceso remoto a la BDD. Afortunadamente, mi hosting actual, Webfaction, me permite todas esas posibilidades y no es ningún un problema. De hecho es el mejor hosting compartido que haya probado nunca y uno de los mejores del mercado, porque su manera de trabajar es única y es lo más parecido a un VPS, pero con una facilidad para administrar las tareas más cotidianas apabullante. Eso si, es distinto a todos los demás y necesita uno adaptarse a su manera de hacer las cosas, pero luego ya no quieres saber nada de otros hosting compartidos. Si además quieres trabajar con ruby o python, pocos puede competir con su flexibilidad, lo que me hizo decidirme por él.

El script, ban_drupal_spammers.py

El script (siempre la versión más actualizada), los ficheros auxiliares y las instrucciones de como emplearlos, pueden ser encontrados en mi repositorio

code.joedicastro.com/ban-drupal-spammers

donde tambien se puede encontrar el script python que empleo para recoger los datos que se muestran en el mapa de este árticulo.

El código de ban_drupal_spammers.py es el siguiente:

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    ban drupal spammers.py: ban spammers in Drupal with Mollom's aid
"""

#===============================================================================
# This Script uses the Mollom reports in Drupal for ban spammers' ips and
# reduce the bandwith usage in the website.
#===============================================================================

#===============================================================================
#    Copyright 2010 joe di castro <joe@joedicastro.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================

__author__ = "joe di castro - joe@joedicastro.com"
__license__ = "GNU General Public License version 3"
__date__ = "15/05/2010"
__version__ = "0.52"

try:
    import sys
    import os
    import time
    import base64
    import collections
    import MySQLdb
    import pygeoip
    import logger
except ImportError:
    # Checks the installation of the necessary python modules
    print((os.linesep * 2).join(["An error found importing one module:",
    str(sys.exc_info()[1]), "You need to install it", "Exit..."]))
    sys.exit(-2)

def connect_db(host, user, pass_, db, port=3306):
    """Connect to MySQL database."""
    try:
        data_base = MySQLdb.connect(host=host, user=user, passwd=pass_, db=db,
                                    port=port, client_flag=65536)
        # flag 65536 is to allow multiple statements in a single string, equals
        # to CLIENT_MULTI_STATEMENTS
    except MySQLdb.OperationalError:
        print("Database connection fails, check that you gave the right "
              "credentials to access the database{0}Exit...".format(os.linesep))
        sys.exit(-2)
    return data_base

def select(curs, sql):
    """Runs a SQL SELECT query and returns a tuple as output."""
    curs.execute(sql)
    return curs.fetchall()

def alter_table(curs, db_table):
    """Create the aux field in the table if no exists, else do nothing."""
    database_string = """
                        ALTER TABLE {0}
                        ADD timestamp INT(11) NOT NULL DEFAULT '0';
                        """.format(db_table)
    try:
        curs.execute(database_string)
        return "Aux Field 'timestamp' in table '{0}' created.".format(db_table)
    except MySQLdb.OperationalError:
        print ("Can't create the aux field, seems this exists previously.")
        # This output is not reported in the log, it will be repetitive.

def ins_qstr(q_mask, q_timestamp):
    """Create a SQL INSERT query string for the given ip."""
    iqstr = """
            INSERT INTO `access`
            (mask, type, status, timestamp)
            VALUES ('{0}', 'host', '0', {1});{2}
            """.format(q_mask, q_timestamp, os.linesep)
    return iqstr

def del_qstr(q_timestamp):
    """Create a DELETE query string for the given timestamp."""
    dqstr = """
            DELETE FROM access
            WHERE timestamp='{0}';{1}
            """.format(q_timestamp, os.linesep)
    return dqstr

def ip_and_country(l_ips, geo):
    """Create the log lines about the ips and their countries."""
    output = None
    if l_ips:
        total = "{0} IPs".format(len(l_ips))
        ips_and_countries = [(geo.country_name_by_addr(l), l) for l in l_ips]
        ips = os.linesep.join(['{0:16} {1}'.format(i[1], i[0]) for  i in
                               sorted(ips_and_countries)])
        output = os.linesep.join([total, '', ips])
    return output

def renew_geoip(gip_path):
    """Check if the geoip data file is too old."""
    out_str = ''
    gz_file = ("http://geolite.maxmind.com/download/geoip/database/"
                "GeoLiteCountry/GeoIP.dat.gz")
    web_url = "http://www.maxmind.com/app/geolitecountry"
    geoip_file_date = os.path.getmtime(gip_path)
    if (time.time() - geoip_file_date) > 2592000: # 2592000s = 30 days
        out_str += ("Your GeoIP data file* is older than 30 days!{0}{0}"
                    "You can look for a new version in:{0}{1}{0}or{0}{2}{0}{0}"
                    "  *{3}".format(os.linesep, gz_file, web_url, gip_path))
    return out_str

def main():
    """main section"""

#===============================================================================
# SCRIPT PARAMATERS
#===============================================================================

    # database host, name or ip ('localhost' by default)
    host = 'localhost'
    # database user name ('root' by default)
    user = 'root'
    # database password, with a minimum security measure, encoded by base64
    # ('password' by default)
    password = base64.b64decode('cGFzc3dvcmQ=')
    # database name ('database' by default)
    database = 'database'

    # path to geolocation data file GeoIP.dat
    geoip_path = '/your/path/to/file/GeoIP.dat'

    # mail server, smtp protocol, to send the log ('localhost' by default)
    smtp_server = 'localhost'
    # sender's email address ('' by default)
    from_addr = ''
    # a list of receiver(s)' email addresses ([''] by default)
    to_addrs = ['']
    # smtp server user ('' by default)
    smtp_user = ''
    # smtp server password, with a minimum security measure, encoded by base64
    # ('password' by default)
    smtp_pass = base64.b64decode('cGFzc3dvcmQ=')

    # set the perfomace threshold (number of banned ips) for you site
    threshold = 2000

#===============================================================================
# END PARAMETERS
#===============================================================================

    # Initialize the log
    log = logger.Logger()
    # log the header
    url = 'http://code.joedicastro.com/ban-drupal-spammers'
    connected = 'Connected to {0} in {1} as {2}'.format(database, host, user)
    log.header(url, connected)

    # log the start time
    log.time('Start Time')

    # log the warning about old geolocation data file
    log.list('The GeoIp.dat file is old', renew_geoip(geoip_path))

    # connect to database, create the cursors & initialize the geolocation info
    mysql_db = connect_db(host, user, password, database)
    cursor = mysql_db.cursor()
    dict_cursor = mysql_db.cursor(MySQLdb.cursors.DictCursor)
    gip = pygeoip.GeoIP(geoip_path)

    # optimize the database (instead a cron task in the server)
    all_tables = [tabl[0] for tabl in select(cursor, "SHOW TABLES")]
    cursor.execute('OPTIMIZE TABLE {0}'.format(', '.join(all_tables)))

    # Adds the timestamp field to the 'access' table if no exists
    log.list('New aux table field created', alter_table(cursor, 'access'))

    # Query the database and obtain the result. We collect the 'access' table
    # ips and ips from spammers reported by Mollom in 'watchdog' table
    # access = ({'timestamp':timestamp, 'mask': 'ip'}, ...)
    # mollom = ({'timestamp':timestamp, 'mask': 'ip'}, ...)
    access = select(dict_cursor, """SELECT mask, timestamp FROM access""")

    mollom = select(dict_cursor, """SELECT hostname as mask, timestamp
                                    FROM `watchdog`
                                    WHERE `type` LIKE '%mollom%'
                                    AND `message` LIKE '%spam:%'""")

    # From the 'access' ips, select the ips blocked by this script from Mollom,
    # discarding those introduced through the Drupal administration interface
    # from_access = {'ip':timestamp, ...}
    from_access = {}
    for a_row in access:
        if int(a_row['timestamp']):
            from_access[a_row['mask']] = a_row['timestamp']

    # Here we select the ips that Mollom reported, if there are multiple
    # occurrences of the same ip, we always choose the most recent
    # from_mollom = {'ip':timestamp, ...}
    from_mollom = {}
    for m_row in mollom:
        if m_row['mask'] in from_mollom.keys():
            if int(from_mollom[m_row['mask']]) < int(m_row['timestamp']):
                from_mollom[m_row['mask']] = m_row['timestamp']
        else:
            from_mollom[m_row['mask']] = m_row['timestamp']

    # Now, from these ips, select the IPs of spammers that were not already
    # banned and generate queries to insert into the 'access' table. It's
    # necessary to check if some of ips reported through Mollom didn't be
    # already banned, because of how the Drupal's event log works. The optional
    # core module "Database logging" (which must be enabled to run his script)
    # is deleting records by the tail (into the 'watchdog' table) on each cron
    # run, according to a maximum limit set in the admin menu. This limit may be
    # 100, 1000, 10000, 100000, 1000000 records, as determined in the "Loggin
    # and alerts -> Database logging" menu. Then depending on the record limit
    # set in the 'watchdog' table, the frequency with which you run the cron job
    # and how often you run this script, it's  very likely that in the previous
    # query we have returned a number of ips that have not yet eliminated from
    # the log ('watchdog'), but we have already added to the table of bannedd
    # ips ('access'). This will avoid duplicate ips on table 'access'
    # ins_ips = ['ip0', 'ip1', ...]
    ins_ips = [f_ip for f_ip in from_mollom.keys() if f_ip not in from_access]
    query_str = ''.join(ins_qstr(i_ip, from_mollom[i_ip]) for i_ip in ins_ips)

    # number of banned ips through this script
    banned_ips = len(from_access) + len(ins_ips)
    # number of banned ips through Drupal administration interface
    drupal_banned_ips = len(access) - len(from_access)

    # After a certain number of records in the table 'access', the website's
    # perfomance deteriorates and from an even larger number, the behavior of
    # Drupal just become erratic. In the case of the site on which to run this
    # script, we see a clear loss of performance from the 3000 records and
    # becomes erratic over 5000. To avoid this unpleasant side effect, and
    # that cure don't be worse than the disease, I set a performance threshold
    # in 2000 records, from which records were removed from the table. If the
    # number of rows is greater than the performance threshold, we proceed to
    # calculate the ips to remove, selecting the oldest. The number of ips to
    # delete will be at least the 30% of "from_access". Just delete records
    # inserted through this script, never the inserted via Drupal admin
    # interface
    trigger = bool(len(access) > threshold) # perfomance threshold

    del_ips, latest = [], 0  # ips to delete (if trigger) & latest ip's date

    if trigger:
        # Now we'll group the ips by date. Use the object collections.defauldict
        # to group the ips in a dictionary of lists (values) of ips by date
        # (keys)
        # ips_by_time = {timestamp:['ip0', ..], ...}
        ips_by_time = collections.defaultdict(list)
        for fa_ip in from_access:
            ips_by_time[from_access[fa_ip]].append(fa_ip)

        # We selected the oldest ips to have a number of them greater than or
        # equal to 30% of blocked by this script
        for ips_date in sorted(ips_by_time.keys()):
            if len(del_ips) < ((len(from_access) * 30) / 100):
                query_str += del_qstr(ips_date) # delete by date, less queries
                for d_ip in ips_by_time[ips_date]:
                    del_ips.append(d_ip)
                    banned_ips -= 1
                if int(ips_date) > latest:
                    latest = int(ips_date)

        latest = time.strftime('%A %x', time.localtime(latest))

        # log spammers' ips deleted from the table
        log.list("Spammers' Ips deleted", ip_and_country(del_ips, gip))
        log.list("Newest date of deleted IPs", "Date: {0}".format(latest))

    # runs the database query
    if query_str:
        cursor.execute(query_str)

    # close database cursors
    cursor.close()
    dict_cursor.close()

    # log spammers' ips inserted into the table
    log.list("Spammers' IPs inserted", ip_and_country(ins_ips, gip))

    # log total banned ips by origin
    log.list('Banned IPs', ['Mollom: %d IPs' % banned_ips,
                            'Drupal: %d IPs' % drupal_banned_ips])
    # log the end time
    log.time('End Time')

    # send the log by email
    log.send('Ban Drupal Spammers. Ins: {0} Del: {1}'.
             format(len(ins_ips), len(del_ips)), send_from=from_addr,
             dest_to=to_addrs, mail_server=smtp_server, server_user=smtp_user,
             server_pass=smtp_pass)

    # write the log to a file
    log.write(True)

if __name__ == "__main__":
    main()

Comentarios realizados anteriormente en Drupal

Muy interesante

por bjone el Jue, 14/10/2010 - 11:40

muy interesante... voy a probar el mollom... gracias por la información.

Preguntita

por Anónimo el Mié, 27/10/2010 - 14:00

Estoy armando mi sitio, que poseerá foro y tendré lo que entendí tu llamas hosting compartido. Es decir, me alquilaran espacio de hosting. La pregunta es: ¿las precauciones contra el spam en mi sitio deberán correr exclusivamente por mi cuenta o parte de la pelea la lleva el administrador de hospedaje?

Gracias.

Gracias, terminé de leer el

por Anónimo el Mié, 27/10/2010 - 14:03

Gracias, terminé de leer el artículo y me respondí solo :)

Si, parece que deberé hacerme cargo activamente :(.

Si, efectivamente así es,

por joe di castro el Mié, 27/10/2010 - 20:04

Si, efectivamente así es, pero además es así también en los servidores administrados y en los servidores dedicados.

A lo sumo se dedican a administrar el hard, el sistema operativo y el sistema base para la web (Apache, Mysql/PostgreSQL, NGINX, PHP, ...). Pero en cuanto a la aplicación web en si misma y todo lo que a ella atañe, es la parte que te toca. Luego dependiendo de según donde acabes teniendo el hosting, en una situación determinada -de un ataque a la web por ejemplo- pueden desde echarte una mano de buena fe hasta exigirte que lo arregles o te cierran la cuenta (si no te la cierran directamente). Depende de con quien des y de la circunstancia que se dé, en la mayoría de hostings compartidos no se paran mucho a dar soporte a este tipo de situaciones, y si a penalizar a los que no gestionan correctamente sus sitios.

De todos modos, si eliges un buen sistema de foros y aplicas un buen sistema antispam, no deberías tener excesivos problemas y acabaras aprendiendo mucho por el camino. La mayoría de los problemas vienen por la desidia y la poca preocupación de los administradores de webs por estos temas.

Saludos y suerte con el foro.

Sobre el Spamicide

por Armonth el Sáb, 30/10/2010 - 19:59

Buenas, yo ese sistema lo conocía por el de "campo oculto" y lo comenté hace ya más de 3 años en SigT (te he enlazado mi nombre al artículo) con la implementación.

Un detalle que cabe mencionar es que es mucho más efectivo poner como campo "te echo atrás por spammer" el campo correspondiente a "nombre" originalmente en la implementación de WordPress (author) y poner un nuevo author que no poner un campo nuevo a ver si lo rellenan.

La mayoría de scripts para spamear no están hechos para rellenar todos los campos, están hechos para rellenar el nombre (author), email, url y comment... ignorando otros campos...

Si, desde luego es bastante

por joe di castro el Sáb, 30/10/2010 - 22:05

Si, desde luego es bastante más lógico hacerlo de esa manera, engañando doblemente a los spammers. De todos modos el modulo Spamicide te deja renombrar el campo como quieras y se puede hacer pasar por uno de esos campos sin problemas, por lo que se puede hacer lo que comentas.

Ya conocía el articulo que enlazas, hace mucho tiempo que te sigo :), aunque los dos estamos muy inactivos últimamente.

Saludos

Bueno

por Armonth el Sáb, 30/10/2010 - 22:57

Bueno, yo estoy "inactivo" de sigt que no de otro proyecto aún no revelado y que dejé los MMO ;P

Las estadísticas de uso emplean los datos de drupal.org a 12 de Octubre de 2010 ↩

Optimizar imagénes para la web

2010-09-07T00:00:00+02:00

El peso (tamaño) de las imágenes de un sitio web es determinante para dos aspectos fundamentales: la velocidad de carga de las páginas y el consumo de ancho de banda.

La velocidad de carga de las páginas es un factor cada día más importante, tanto para el posicionamiento de la web, como para la experiencia del usuario, que cada vez es más impaciente. El consumo de ancho de banda también es un factor muy importante, en cuanto a que suele estar directamente relacionado con el coste económico del alojamiento del sitio.

Y aunque generalmente los programas de retoque fotográfico más comunes incorporan ya opciones especiales para guardar imágenes para la web, no todos exprimen al máximo el potencial de eliminar información superflua de una imagen (bueno, el EXIF puede no serlo tanto, dependiendo del sitio) sin que se vea afectada la calidad de la misma.

Yahoo, en sus consejos para optimizar la velocidad de carga de un sitio web, "Yahoo Best Practices for Speeding Up Your Web Site", recomienda una serie de pequeñas aplicaciones en su apartado para optimizar las imágenes.

Son una serie de ordenes de línea comandos que han de aplicarse a las imágenes, una por una, algo tedioso y poco optimo si nuestro sitio web tiene cientos o miles de imágenes.

Por eso he creado un script en Python, img4web.py, que automatiza todo el proceso y procesa todas las imágenes en formatos .png y .jpg que se encuentren en una carpeta.

Es muy sencillo de utilizar y al final del proceso tendremos una nueva carpeta "processed" con todas las imágenes y un resumen del proceso como este:

================================================================================  
                                    Summary                                       
================================================================================  
         Original            Processed           Save

.jpgs:   ( 31)  2.12 MiB     ( 31)  1.82 MiB     301.28 KiB  
.pngs:   ( 10)489.46 KiB     ( 10)368.93 KiB     120.53 KiB  
--------------------------------------------------------------------------------  
Total:   ( 41)  2.60 MiB     ( 41)  2.19 MiB     421.81 KiB

El script, las revisiones del código y las instrucciones de como descargarlo y usarlo podéis encontrarlas en mi repositorio.

Funciona tanto en Linux como en Windows, no lo he probado en un Mac.

El código del script, es el siguiente:

#!/usr/bin/env python
# -*- coding: <utf8> -*-

"""
    img4web.py: optimize .jpg and .png images for the web
"""

#===============================================================================
# This Script optimizes .jpg and .png images for the web.
#
# This follows the "Yahoo Best Practices for Speeding Up Your Web Site" about
# optimize images. 
# http://developer.yahoo.com/performance/rules.html#opt_images
# 
# Uses the program pngcrush and the command jpegtran of the libjpeg library
# 
# pngcrush, http://pmt.sourceforge.net/pngcrush/
# libjpg, http://www.ijg.org/
#
# In Linux they are usually available in the most popular distribution 
# repositories, e.g.: 
# In debian, Ubuntu as these packages:
# pngcrush
# libjpeg-progs
#
# In Windows pngcrush can be downloaded at 
# http://sourceforge.net/projects/pmt/files/pngcrush-executables/
# and libjpeg can be downloaded (as gnuwin32) at 
# http://gnuwin32.sourceforge.net/downlinks/jpeg.php
#
# How it runs?
#
# Get a list of .jpg and .png images in the working directory (where script 
# runs) and process all of them one by one. Store the processed images in a new
# subdirectory named 'processed' (I know, I didn't killed myself worrying about 
# the name)
#===============================================================================

#===============================================================================
#    Copyright 2009 joe di castro <joe@joedicastro.com>
#       
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================

__author__ = "joe di castro - joe@joedicastro.com"
__license__ = "GNU General Public License version 2"
__date__ = "30/12/2010"
__version__ = "0.4"

try:
    import sys
    import glob
    import os
    import platform
    import re
    from subprocess import Popen, PIPE, call
except ImportError:
    # Checks the installation of the necessary python modules 
    print((os.linesep * 2).join(["An error found importing one module:",
    str(sys.exc_info()[1]), "You need to install it", "Stopping..."]))
    sys.exit(-2)

def best_unit_size(bytes_size):
    """Get a size in bytes & convert it to the best IEC prefix for readability.

    Return a dictionary with three pair of keys/values:

    's' -- (float) Size of path converted to the best unit for easy read
    'u' -- (str) The prefix (IEC) for s (from bytes(2^0) to YiB(2^80))

    """
    for exp in range(0, 90 , 10):
        bu_size = abs(bytes_size) / pow(2.0, exp)
        if int(bu_size) < 2 ** 10:
            unit = {0:'bytes', 10:'KiB', 20:'MiB', 30:'GiB', 40:'TiB', 50:'PiB',
                    60:'EiB', 70:'ZiB', 80:'YiB'}[exp]
            break
    return {'s':bu_size, 'u':unit}

def get_size(the_path):
    """Get size of a directory tree or a file in bytes."""
    path_size = 0
    for path, directories, files in os.walk(the_path):
        for filename in files:
            path_size += os.lstat(os.path.join(path, filename)).st_size
        for directory in directories:
            path_size += os.lstat(os.path.join(path, directory)).st_size
    path_size += os.path.getsize(the_path)
    return path_size

def check_execs_posix_win(*progs):
    """Check if the programs are installed.

    Returns two values:

    (dict) windows_paths - a dictionary of executables/paths (keys/values)
    (boolean) is_windows - True it's a Windows OS, False it's a *nix OS

    """
    def not_found(app):
        """ If executable is not installed, exit and report."""
        msg = 'The {0} program is necessary to run this script'.format(app)
        sys.exit(msg)

    windows_paths = {}
    is_windows = True if platform.system() == 'Windows' else False
    # get all the drive unit letters if the OS is Windows
    windows_drives = re.findall(r'(\w:)\\',
                                Popen('fsutil fsinfo drives', stdout=PIPE).
                                communicate()[0]) if is_windows else None
    for prog in progs:
        if is_windows:
            # Set all commands to search the executable in all drives
            win_cmds = ['dir /B /S {0}\*{1}.exe'.format(letter, prog) for
                        letter in windows_drives]
            # Get the first location (usually in C:) of the all founded where 
            # the executable exists
            exe_paths = (''.join([Popen(cmd, stdout=PIPE, stderr=PIPE,
                                        shell=True).communicate()[0] for
                                        cmd in win_cmds])).split(os.linesep)[0]
            # Assign the path to the executable or report not found if empty
            windows_paths[prog] = exe_paths if exe_paths else not_found(prog)
        else:
            try:
                Popen([prog, '--help'], stdout=PIPE, stderr=PIPE)
            except OSError:
                not_found(prog)
    return windows_paths, is_windows

def main(execs, windows):
    """Main section."""
    # Check if exists the subdirectory for store the results, else create it
    dest_path = os.path.join(os.getcwd(), 'processed')
    if not os.path.exists(dest_path):
        os.mkdir(dest_path)

    # Get the list of all .png an .jpg images in the current folder by type
    jpg, png = glob.glob('*.jp[e|g]*'), glob.glob('*.png')

    # Get the original size of the images in bytes by type
    org_jpg_sz = sum((get_size(orig_jpg) for orig_jpg in jpg))
    org_png_sz = sum((get_size(orig_png) for orig_png in png))

    # Get the executable's names (and path for windows) of the needed programs 
    jpegtran = execs['jpegtran'] if windows else 'jpegtran'
    pngcrush = execs['pngcrush'] if windows else 'pngcrush'

    # Process all .jpg images
    for jpg_img in jpg:
        call([jpegtran, '-copy', 'none', '-optimize', '-perfect', '-outfile',
              os.path.join(dest_path, jpg_img), jpg_img])

    # Process all .png images
    for png_img in png:
        call([pngcrush, '-rem', 'alla', '-reduce', '-brute',
              png_img, os.path.join(dest_path, png_img)])

    # Get the size of the processed images in bytes by type
    os.chdir(dest_path)
    prc_jpg = [j for j in glob.glob('*.jp[e|g]*') if j in jpg]
    prc_png = [p for p in glob.glob('*.png') if p in png]
    prc_jpg_sz = sum((get_size(new_j) for new_j in prc_jpg))
    prc_png_sz = sum((get_size(new_p) for new_p in prc_png))

    # Get a human readable size
    ojs, ops = best_unit_size(org_jpg_sz), best_unit_size(org_png_sz)
    pjs, pps = best_unit_size(prc_jpg_sz), best_unit_size(prc_png_sz)
    tot_org = best_unit_size(org_jpg_sz + org_png_sz)
    tot_prc = best_unit_size(prc_jpg_sz + prc_png_sz)
    sjs = best_unit_size(org_jpg_sz - prc_jpg_sz)
    sps = best_unit_size(org_png_sz - prc_png_sz)
    tts = best_unit_size((org_jpg_sz + org_png_sz) - (prc_jpg_sz + prc_png_sz))

    # print a little report    
    print('{0}{1}{0}{2:^80}{0}{1}'.format(os.linesep, '=' * 80, 'Summary'))
    print('         Original            Processed           Save' + os.linesep)
    print('.jpgs:   ({6:3}){0:>6.2f} {1:8}({7:3}){2:>6.2f} {3:8}{4:>6.2f} {5}'.
          format(ojs['s'], ojs['u'], pjs['s'], pjs['u'], sjs['s'], sjs['u'],
                 len(jpg), len(prc_jpg)))
    print('.pngs:   ({6:3}){0:>6.2f} {1:8}({7:3}){2:>6.2f} {3:8}{4:>6.2f} {5}'.
          format(ops['s'], ops['u'], pps['s'], pps['u'], sps['s'], sps['u'],
                 len(png), len(prc_png)))
    print('-' * 80)
    print('Total:   ({6:3}){0:>6.2f} {1:8}({7:3}){2:>6.2f} {3:8}{4:>6.2f} {5}'.
          format(tot_org['s'], tot_org['u'], tot_prc['s'], tot_prc['u'],
                 tts['s'], tts['u'],
                 (len(jpg) + len(png)), (len(prc_jpg) + len(prc_png))))

if __name__ == "__main__":
    WIN_EXECS, WIN_OS = check_execs_posix_win('jpegtran', 'pngcrush')
    main(WIN_EXECS, WIN_OS)

Para una versión actualizada del código ir a el fichero fuente.

TED Talks, descargar videos y subtitulos de las charlas

2010-07-29T22:01:00+02:00

Como introducción, para aquellos que aun no conozcan TED (Technology, Enternaiment, Design) y sus famosas charlas, TED Talks, podría resumirlo como algo así como la versión en vídeo de las revistas de "divulgación científica y tecnológica" (acogiendo bajo esta denominación desde las más banales a las mas prestigiosas) que todos conocemos como Muy Interesante, Investigación y Ciencia, Geo, Quo, National Geographic, Popular Science, Nature, Science, Lancet, etc... con la ventaja de la escasa distorsión del mensaje y lo conciso del mismo. Esto se debe a que no tenemos que pasar por el filtro del periodista (cuando no es un paper), es el propio interesado quien nos relata sus ideas personalmente y que la gran mayoría de las charlas esta sometida a un tiempo limite de 18 minutos, ya que es el tiempo máximo que se ha calculado que podemos estar centrados en un solo asunto sin perder el interés o la atención. Evidentemente no son comparables a un articulo amplio, detallado y bien redactado o a un buen documental, ni tampoco lo pretenden. No se trata de profundizar en los temas, se trata de que el ponente consiga transmitirte sus ideas, su entusiasmo y la trascendencia de las mismas, y en la mayoría de los casos lo consiguen, y algunas de estas charlas son de una calidad y de una trascendencia tales, que deberían tener lugar también en los medios tradicionales (TV). La calidad de estas charlas es tal que es difícil no quedarte impresionado (cuando no deslumbrado) al final de las mismas y contagiado del entusiasmo de los ponentes, la apertura de miras, conocimiento y humildad que te proporcionan (amen de ayudarte a creer un poquito más en la humanidad) no tiene parangón actualmente. Desde la serie Cosmos de Carl Sagan, no he encontrado nada parecido que me invitara tanto a pensar y me abriera tanto la mente. Lo único que se acerca, entre la telebasura reinante, en el mundo audiovisual actual, es el programa Redes de Eduardo Punset.

Para una definición más precisa, un extracto del articulo de la Wikipedia:

Estas charlas se publican en su pagina web actualmente a un ritmo aproximado de una por día de semana (esto es, lunes a viernes). Actualmente (julio 2010) hay más de 700 charlas disponibles en su página y se han visionado más de 290.000.000 de veces (julio 2010), para que os hagáis una idea de la repercusión y trascendencia de las mismas.

El caso es que yo las sigo habitualmente, vamos que veo todas las que publican. Al principio me limitaba a enterarme de la publicación de las mismas por mi lector de fuentes RSS, veía el asunto de las mismas y si me parecía interesante, las veía directamente a través de su página web. Luego, cansado de los inconvenientes de verlas a través de un navegador web a pantalla completa, en flash desde Linux, dí un paso más y me pase a un programa como Miro, de hecho hay una versión del mismo para TED. Para el que no lo conozca, Miro es un reproductor multimedia open source multiplataforma que cuenta con un agregador de fuentes RSS y torrents para podcasts de audio y vídeo. Así que él automáticamente se baja las charlas a medida que se van publicando y tu solo tienes que visionarlas desde el mismo, decidiendo después si las eliminas o las conservas.

Pero Miro para mi tenia dos grandes problemas, el primero que no descarga los subtitulos, y el segundo que la visualización de estos es bastante pobre (al menos comparado con la configuración que tengo en mi SMPlayer). No es que los subtitulos me sean esenciales (todas las charlas son en ingles) pero si que ayudan mucho para el contexto de aquellas donde uno ni de lejos domina los tecnicismos de algunos campos, o porque no decirlo, cuando el acento o la pronunciación de algunos de los ponentes me hace imposible seguirlos sin los mismos. Siempre veo los subtitulos en el idioma original, inglés, pero siempre descargo también la versión en español porque me es muy útil en algunos momentos, como por ejemplo cuando se refieren a especies animales o vegetales de los que no conozco la traducción al español, y en lugar de tirar de diccionario continuamente, gano tiempo visionandolos en castellano.

Como uno ha de reconocer humildemente, rara es la vez que a uno no se le presente un problema que no se le haya presentado antes a otro y no haya dado con una solución valida. Luego en vez de reinventar la rueda (aunque finalmente es lo que haya acabado haciendo) me dirigí a San Google para encontrar una solución para descargar los subtitulos de las TED Talks, y he aquí, que doy con este script en Python (mi lenguaje de programación favorito). Lo empleé durante unos días (tres para ser exactos), pero no me acaba de convencer y me puse a modificarlo, y cuando estaba en ello, me dije: Que demonios! si al final no te convence Miro para visionar los vídeos con subtitulos, porque no descargar también los mismos y utilizar el SMPlayer para visionarlos? Así que me puse manos a la obra, y esto es lo que salio y actualmente empleo.

El script hace uso de la fuente RSS de las TED Talks en calidad HD para conocer cuando se publica una nueva charla en la pagina. Comprueba si no esta ya descargado, si no es así, lo descarga y luego comprueba la disponibilidad de los subtitulos (español e ingles) para las charlas ya descargadas que se encuentren en la carpeta. Si encuentra alguno disponible y no descargado anteriormente, lo convierte en un nuevo fichero .srt en la carpeta. Finalmente, si se ha descargado algo (charlas o subs), manda un correo a mi usuario local notificándomelo. Esta script lo tengo automatizado mediante una tarea cron en un pequeño servidor que tengo y que se ejecuta todas las mañanas a eso de las 9:30 y que normalmente me descarga la charla del día anterior y los subtitulos en ingles de la misma y los de español de dos días antes. Esto depende mucho de la velocidad de traducción de los colaboradores, ya que a veces, cuando una charla es muy interesante, es posible que a las pocas horas dispongamos de los subtitulos en los dos idiomas.

La parte fundamental del código del script, es la siguiente:

def get_sub(tt_id , tt_intro, sub):
    """Get TED Subtitle in JSON format & convert it to SRT Subtitle
    Obtiene el subtitulo de TED en formato JSON y lo convierte al formato SRT"""

    def srt_time(tst):
        """Format Time from TED Subtitles format to SRT time Format
        Convierte el formato de tiempo del subtitulo TED al formato de SRT"""
        secs, mins, hours = ((tst / 1000) % 60), (tst / 60000), (tst / 3600000)
        right_srt_time = "{0:02d}:{1:02d}:{2:02d},000".format(hours, mins, secs)
        return right_srt_time

    srt_content = ''
    sub_log = ''
    tt_url = 'http://www.ted.com/talks'
    sub_url = '{0}/subtitles/id/{1}/lang/{2}'.format(tt_url, tt_id, sub[-7:-4])
    ## Get JSON sub
    if FOUND:
        json_file = Popen(['wget', '-q', '-O', '-', sub_url],
                          stdout=PIPE).stdout.readlines()

        if json_file:
            for line in json_file:
                if line.find('captions') == -1 and line.find('status') == -1:
                    json_file.remove(line)
        else:
            sub_log += "Subtitle '{0}' not found.{1}".format(sub, os.linesep)
    else:
        json_file = urllib2.urlopen(sub_url).readlines()
    try:
        json_object = json.loads(json_file[0])
        if 'captions' in json_object:
            caption_idx = 1
            if not json_object['captions']:
                sub_log += ("Subtitle '{0}' not available.{1}".
                            format(sub, os.linesep))
            for caption in json_object['captions'] :
                start = tt_intro + caption['startTime']
                end = start + caption['duration']
                idx_line = '{0}'.format(caption_idx)
                time_line = '{0} --> {1}'.format(srt_time(start), srt_time(end))
                text_line = '{0}'.format(caption['content'].encode("utf-8"))
                srt_content += '\n'.join([idx_line, time_line, text_line, '\n'])
                caption_idx += 1
        elif 'status' in json_object:
            sub_log += ("This is an error message returned by TED:{0}{0} - {1}"
                        "{0}{0}Probably because the subtitle '{2}' is not "
                        "available.{0}{0}{0}"
                        "".format(os.linesep, json_object['status']['message'],
                                  sub))

    except ValueError:
        sub_log += ("Subtitle '{0}' it's a malformed json file.{1}".
                    format(sub, os.linesep))
    return srt_content, sub_log

def check_subs(ttalk, v_name):
    """Check if the subtitles for the talk are downloaded, if not try to get
    them. Checks it for english and spanish languages
    Comprueba si los subtitulos para la charla estan descargados, si no, intenta
    obtenerlos. Lo comprueba para los idiomas español e ingles"""
    ## Get the names for the subtitles (for english and spanish languages) only
    # if they not are already downloaded
    subs = (s_name for s_name in
            ("{0}.{1}.srt".format(v_name[:-4], lang) for lang in ('eng', 'spa'))
            if s_name not in glob.glob('*.srt'))
    s_log = ''
    for sub in subs:
        ## Reads the talk web page, to search the talk's intro duration
        if FOUND:
            tt_webpage = Popen(['wget', '-q', '-O', '-',
                                ttalk.feedburner_origlink],
                                stdout=PIPE).stdout.read()
        else:
            tt_webpage = urllib2.urlopen(ttalk.feedburner_origlink).read()
        tt_intro = int(search("introDuration:(\d+),", tt_webpage).group(1))
        subtitle, get_log = get_sub(ttalk.id.split(':')[-1], tt_intro, sub)
        s_log += get_log
        if subtitle:
            with open(sub, 'w') as srt_file:
                srt_file.write(subtitle)
            s_log += "{0}{1} downloaded.{0}".format(os.linesep, sub)
    return s_log

def get_video(ttk, vid_url, vid_name):
    """Gets the TED Talk video
    Obtiene el video de la TED Talk"""
    if FOUND:
        Popen(['wget', '-q', '-O', vid_name, vid_url], stdout=PIPE).stdout.read()
    else:
        urllib.urlretrieve(vid_url, vid_name)
    v_log = '{0} ({1})\n'.format(ttk.subtitle, ttk.itunes_duration)
    v_log += '{0}\n\n'.format('=' * (len(ttk.subtitle) + 11))
    v_log += '{0}\n\n'.format(ttk.feedburner_origlink)
    v_log += '{0}\n\n'.format(ttk.content[0].value)
    v_log += 'file://{0}\n'.format(os.path.join(os.getcwd(), vid_name))
    vid_size = best_unit_size(get_size(vid_name))
    v_log += '{0:.2f} {1}\n\n'.format(vid_size['s'], vid_size['u'])
    return v_log

def main():
    """main section"""

#===============================================================================
# SCRIPT PARAMETERS
#===============================================================================

    ## The directory to store the videos and subs.
    # For Windows change the character '\' for the character '/', I know is
    # akward but is because how escape strings python
    ttalk_vid_dir = '/your/path/to/TED/Talks/Videos'

#===============================================================================
# END PARAMETERS
#===============================================================================

    # initalize the log
    log = Logger()

    # log the header
    url = 'http://code.joedicastro.com/ted-talks-download'
    msg = 'Download TED Talks from HD RSS Feed'
    log.header(url, msg)

    # log the start time
    log.time('Start Time')

    os.chdir(os.path.normpath(ttalk_vid_dir))

    ## Get a list of the current TED Talks downloaded in the dir
    videos = glob.glob('*.mp4')

    ## Get the last download Talk video date
    try:
        with open('.data.pkl', 'rb') as pkl_file:
            last = pickle.load(pkl_file)
    except (EOFError, IOError, pickle.PickleError):
        last = time.localtime(time.time() - 86400)
    video_dates = []

    ## The TED Talks HD RSS feed
    ttalk_feed_url = 'http://feeds.feedburner.com/tedtalksHD'
    ttalk_feed = feedparser.parse(ttalk_feed_url)

    ## If the feed is erroneous or occurs a http or network error, log and exit!
    if ttalk_feed.bozo:
        log.list('An error occurred', str(ttalk_feed.bozo_exception))
        if not WIN_OS:
            log.send('Download TED Talks')
        sys.exit(1)

    ## If correct, process the feed entries
    vids_log, subs_log = '', ''
    for ttalk_entrie in ttalk_feed.entries:
        ## Get The video url and name
        tt_vid_url = ttalk_entrie.enclosures[0].href
        tt_vid_name = tt_vid_url.split('/')[-1]
        ## If the video is new, download it!
        if ttalk_entrie.updated_parsed > last and tt_vid_name not in videos:
            vids_log += get_video(ttalk_entrie, tt_vid_url, tt_vid_name)
            videos.append(tt_vid_name)
            video_dates.append(ttalk_entrie.updated_parsed)
        ## If video is already downloaded, check if subs exists, if not, get it!
        if tt_vid_name in videos:
            subs_log += check_subs(ttalk_entrie, tt_vid_name)
    log.list('Talks downloaded', vids_log)
    log.list('Subs downloaded', [subs_log])

    ## Set the last download video date
    if video_dates:
        last = max(video_dates)
        with open('.data.pkl', 'wb') as output:
            pickle.dump(last, output)

    log.time('End time')
    ## If logs any activity, sends the information mail
    if not WIN_OS:
        log.send('Download TED Talks')
    log.write(False)

if __name__ == "__main__":
    WIN_OS = True if platform.system() == 'Windows' else False
    if not WIN_OS:
        FOUND = check_exec_posix('wget')
    main()

Y un ejemplo de un correo enviado por el mismo quedaría así:

De:     youruser@yourcomputer
Para:     youruser@yourcomputer
Asunto:     Download TED Talks - Thursday 07/29/10, 17:04:52
Fecha:     Thu, 29 Jul 2010 17:04:52 +0200

New TED Talk downloaded!
========================
http://www.ted.com/talks/view/id/927

Laurie Santos: A monkey economy as irrational as ours (00:19:45)

Laurie Santos looks for the roots of human irrationality by watching the way
our primate relatives make decisions. A clever series of experiments in
"monkeynomics" shows that some of the silly choices we make, monkeys make too.

file:///your/path/to/TEDTalks/LaurieSantos_2010G_480.mp4
240.7 MiB

SusanShaw_2010X_480.eng.srt downloaded

Pudiendo acceder al vídeo directamente desde el correo, y si se encontraran los subtítulos para el mismo ya disponibles, visualizarlos automáticamente.

El que el script esté fundamentalmente en ingles (la mayoría de comentarios y los nombres de las variables) es que me siento más cómodo de esta manera y ayuda a que un espectro más amplio de personas sea capaz de comprenderlo. Si este script le sirve a alguien más o le inspira para crear el suyo propio, pues habrá valido la pena el publicarlo. El resto del script, TEDTalks.py está disponible en mi repositorio de bickbucket, al igual que instrucciones ampliadas de su uso.

Finalmente como ejemplo, publico una de las charlas más impactantes este año y ganadora del TED Prize, Jamie Oliver: Enseñarle a todos los niños acerca de la comida

Comentarios realizados anteriormente en Drupal

Excelente!

por Dennis el Sáb, 31/07/2010 - 21:12

Amigo, he leído con atención su articulo acerca de los subtítulos. El nivel de automatización alcanzado resulta sorprendente, sin embargo, para aquellos que no contamos con el hardware necesario se torna complicada la cosa.

En mi caso, me interesa descargar algunas (no todas) las charlas. De hecho, quisiera unas pocas, cuidadosamente seleccionadas, para presentarlas en el colegio en el cual doy clases a mis alumnos de secundaria.

¿Conoce Ud. de alguna forma de descargar en un formato legible por VLC (.SUB o .SRT, por ejemplo) los subtítulos en español de charlas seleccionadas? He estado tratando de conseguir algunos en forma infructuosa desde hace algún tiempo, aunque he conseguido algunos en formato JSON.

Gracias mil por la ayuda con este tema.

Script para subtitulos de una charla

por joe di castro el Dom, 01/08/2010 - 01:38

Bueno, para conseguir eso que me comentas, he modificado el script anterior un poco y he creado este nuevo script.

La forma de utilizarlo es muy sencilla, por ejemplo para bajarse la charla de Jamie Oliver, simplemente en la linea de comandos escribes

python TEDSubs.py http://www.ted.com/talks/lang/eng/jamie_oliver.html

Y el te baja tanto los subtítulos como el vídeo. Si quisieras bajarte solo los subtítulos, bastaría con que añadieras la opción -s ó --only_subs, quedaría así:

python TEDSubs.py -s  http://www.ted.com/talks/lang/eng/jamie_oliver.html

Como ves es muy sencillo, solo tendrías que sustituir la dirección de la charla de Oliver por la que deseas bajar.

Espero que te sirva.

Saludos

TED

por Ignacio el Mié, 04/08/2010 - 01:02

Estimado muy bueno lo que haces, me parecen excelentes los vídeos y me gustaría contar con ellos. ¿Donde corro el script?¿podrías subírmelos con subtítulos a algún gestor o ftp?

Muchas gracias

Vamos por partes...

por joe di castro el Jue, 05/08/2010 - 19:47

Vamos por partes...

Los scripts los ejecutas en tu ordenador, lo único necesario es el lenguaje de programación Python y una conexión a Internet. Si tu maquina corre en linux, el python lo tienes instalado por defecto en casi todas las distribuciones. Si corre en Windows o Mac, lo puedes descargar en Python.org

Para correr los scripts, en la linea de comandos solo necesitas ejecutar estas lineas de comando:

python TEDTalks.py

para el primer script o las lineas de comando ya comentadas anteriormente para el segundo script.

Para descargarlos, puedes o bien copiar y pegar el código tal y como aparece en el articulo, o bien descargarlos:

TEDTalks.py & TEDSubs.py

o bien vas directamente al mi repositorio en bitbucket

Eso si, hay que tener en cuenta que en el caso del primer script, este solo se baja el vídeo del dia anterior en su primera ejecución o bien el más reciente no descargado en caso de ejecuciones sucesivas. Y como la gente de TED parece que se ha tomado un descanso en Agosto (el último vídeo es del 30 de Julio), este no descargara nada, porque de momento no hay nada que descargar. Hasta que no retornen la publicación de nuevas charlas, el primer script no bajara nuevos contenidos, igual que los tradicionales lectores RSS o el mismo Miro.

Saludos

Gracias

por Daniel el Mié, 22/09/2010 - 04:38

Hermano, muchas gracias.. excelente script.. ya te imaginaras lo importante que es que para muchos, poder adquirir estas excelente conferencias. Gracias de nuevo

Funcionan los Subtitulos?

por Xavier el Mié, 24/11/2010 - 00:35

Hola,

muchas gracias por disponibilizar los scripts.

Estoy intentando usar el segundo script (para bajar vídeos concretos) pero solo me baja el vídeo. Si lo uso con -s no me baja nada (tampoco devuelve ningún mensaje de error.

Podría ser que hayan cambiado la manera de bajar los subtítulos?

gracias por adelantado

Xavier

Si, funcionan, pero...

por joe di castro el Mié, 24/11/2010 - 09:28

Si, funcionan, pero a veces los subtítulos aún no están disponibles, o peor, el fichero original en formato json es defectuoso. Lo de que el formato json sea defectuoso suele pasar de vez en cuando y generalmente acaban solucionándolo al cabo de unos días. Debe de ser algún defecto en la traducción o al subir el fichero.

De todos modos ya he modificado el script para que te muestre un mensaje de error en caso de que no esté disponible o este defectuoso, e indicado si es el subtitulo en español o ingles. Puedes descargarlo de aquí o del repositorio. Gracias por informarme del error, se me había escapado el proporcionar esta información.

Y voy a mirar la manera de convertir igualmente el subtitulo de json a srt aunque el json esté malformado siempre que sea posible. No será muy difícil.

Saludos

Actualización: Bueno, he encontrado un fallo, a veces cuando la página termina un cierto tiempo en responder, no cargaba algunos ficheros json de subtítulos completos, y lo interpretaba como un fichero json defectuoso. Ya he corregido el error, substituyendo la función que empleaba para la descarga por otra que siempre descarga el fichero completo.

Bueno, ya estan incorporadas

por joe di castro el Mié, 24/11/2010 - 23:26

Bueno, ya están incorporadas las mejoras también al otro script. En principio no veo necesario el crear el método para los ficheros JSON defectuosos, en parte porque sería replicar más o menos lo que ya hace el modulo json y en parte porque los JSON defectuosos provenían del empleo de la librería de python urllib para descargarlos, lo que a veces por timeouts no conseguía hacerlo del todo. El emplear la librería urllib2 soluciona este problema puesto que si los descarga al completo.

De todos modos ahora se reportan todos los códigos de error que aparezcan, tanto los que genero yo en el script, como los originales generados por TED (en realidad dotSUB, que es el que proporciona los subtítulos para TED) y les haré un seguimiento. Porque puede que si estén cambiando algo, dados los errores que reportan algunos de los últimos vídeos.

Saludos y gracias por reportarme el fallo, Xavier.

Aun tengo algun problemilla

por Xavier el Jue, 25/11/2010 - 00:40

Muchas gracias por tan rápida respuesta. Me he copiado el código para bajar los vídeos individuales, pero aun tengo problemas. Esta vez parece como si me faltara algún modulo de python, aunque no se ni cual ni como debo actualizarlo. Tengo el siguiente error:

Traceback (most recent call last):
  File "./TEDVideos.py", line 184, in <module>
    main()
  File "./TEDVideos.py", line 172, in main
    ttalk_webpage).group(1)) 
AttributeError: 'NoneType' object has no attribute 'group'

(El programa TEDVideos.py es el nombre que le he dado yo a tu código)

muchas gracias de antemano

No, en este caso no te falta

por joe di castro el Jue, 25/11/2010 - 10:12

No, en este caso no te falta ningún modulo para ejecutar el script, eso es algo que ya tengo contemplado y es lo primero que compruebo, y lanzo un aviso del modulo que es necesario para ejecutarlo si no se encuentra.

El error que me muestras es porque intento seleccionar uno de entre los resultados de una búsqueda de datos dentro de una página web, y al ser el resultado de la búsqueda vacío arroja ese error. Es un error que tampoco tenía contemplado porque asumía que en un principio las direcciones web introducidas serían correctas, algo que voy a contemplar a partir de ahora, para avisar al usuario.

Ese error te lo da porque no encuentra lo que busca, el identificador único de la charla, en la página web que le proporcionas. Lo raro es que si fuera una dirección web incorrecta, el error tendría que producirse antes, cuando busca la duración de la introducción previa al vídeo. Lo he probado con unas 25 charlas diferentes y no he conseguido reproducir el error. La mejora forma de entender lo que ha pasado es que me proporciones la dirección web que te da el error para comprobar lo que ocurre.

Saludos

Actualización: He añadido mensajes de error para contemplar estas posibilidades, así será más fácil diagnosticar los fallos.

En efecto, no encuentra la página

por Xavier el Jue, 25/11/2010 - 12:01

Tal y como predices, no parece encontrar la pagina buscada. Ahora me lanza este error:

Some data not found in this URL:

http://www.ted.com/talks/lang/eng/jamie_oliver.html

Please report this error and provides the URL to check at:

http://code.joedicastro.com/ted-talks-download/issues/new

Thanks for helping to fix errors.

Lo curioso es que estoy probándolo con el ejemplo que tu nos proporcionas:

TEDSubs.py -s  http://www.ted.com/talks/lang/eng/jamie_oliver.html

Para asegurarme que tengo conectividad desde mi ordenador he intentado ir a la pagina web en un browser (sale ok) y he intentado bajarla con wget (baja ok).

No creo que afecte, pero estoy usando OS X 10.6

gracias

Xavier

Bueno, teniendo en cuenta los

por joe di castro el Jue, 25/11/2010 - 12:33

Bueno, teniendo en cuenta los errores que te da ahora y que al principio si podías bajar el vídeo, el problema está en el cambio que hice de urllib a urllib2, pero si el segundo te da este error, el primero no te bajaba los subtítulos. He mirado googleando un poco y si parece haber algunos problemas con estas librerías y MAC OSX, es algo que no puedo corroborar directamente puesto que no dispongo de este SO para probarlo.

Así que voy a ir por terreno seguro y aprovechando el feedback que me das, voy a prepararte una versión que emplee la herramienta externa wget para coger los datos de la página, los subtítulos y el vídeo. De este modo nos aseguramos de sortear este problema.

De nada, la pena es no tener un Mac, si no, no te hacia dar tantas vueltas.

Saludos

Ya tienes la nueva versión

por joe di castro el Jue, 25/11/2010 - 14:00

Ya tienes la nueva versión con wget, esta no debería darte esos problemas. Ya me dirás el resultado.

Saludos

fantástico!

por Xavier el Jue, 25/11/2010 - 14:43

Ahora ya funciona perfectamente!

muchas gracias por añadir estas funcionalidades y por los scripts. Van a serme de grande utilidad.

un saludo,

Xavier

De nada, gracias a ti por el

por joe di castro el Jue, 25/11/2010 - 14:47

De nada, gracias a ti por el feedback, le servirá a futuros usuarios.

Luego modifico también el otro script para emplear wget.

Un saludo

Joe

Nuevas versiones mejoradas de

por joe di castro el Mié, 01/12/2010 - 23:51

Nuevas versiones mejoradas de los scripts (versión 1.3) y probadas en las 831 charlas disponibles hasta hoy, contemplando todos los casos diferentes.

Saludos