joe di castro

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 como el fichero djvu2pdf.py dentro del repositorio Python Recipes que está alojado en github y actualizado siempre a la última versión.

#!/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()

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://joedicastro.com

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://joedicastro.com"
    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 el repositorio Python Recipes alojado en github.

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 en mi repositorio Python Recipes que se encuentra alojado en github. 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

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://joedicastro.com

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://joedicastro.com'
    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 el repositorio Python Recipes en github.

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://joedicastro.com

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://joedicastro.com"
    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 Python Recipes en github.

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. ↩

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 el fichero check_execs.py en mi repositorio Python Recipes que se encuentra alojado en github.

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 Python Recipes que está alojado en github.

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 el repositorio Python Recipes alojado en github.

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 en github.

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://joedicastro.com'
    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.

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 que se encuentra alojado en github.Y 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://joedicastro.com'
    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 el repositorio que está alojado en github.

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:

TED (Tecnología, Entretenimiento, Diseño, del inglés: Technology, Entertainment, Design) es una organización sin ánimo de lucro dedicada a las "ideas que vale la pena difundir" (del inglés: Ideas worth spreading). TED es ampliamente conocida por su conferencia anual (TED Conference) y sus charlas (TED Talks) que cubren un amplio espectro de temas que incluyen ciencias, arte y diseño, política, educación, cultura, negocios, asuntos globales, tecnología y desarrollo, y entretenimiento. Los conferenciantes han incluido a personas como el ex-Presidente de los Estados Unidos Bill Clinton, los laureados con el Premio Nobel James D. Watson, Murray Gell-Mann, y Al Gore, el co-fundador de Microsoft, Bill Gates, los co-fundadores de Google Sergey Brin y Larry Page, y Billy Graham

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://joedicastro.com'
    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 alojado en github, 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 github

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