Configurando un proyecto Django para acceder desde la red

Hace mucho mucho tiempo que empecé a trabajar con Django, el framework de Python para crear contenidos web. Sin embargo, me ha costado mucho trabajo averiguar cómo configurar un proyecto para ser visto desde la red de la UGR. Aquí vemos cómo se hace utilizando Mod-WSGI y Apache.

Instalamos Mod-WSGI para Apache desde apt-get:

$ sudo apt-get install apache2-mod-wsgi

Creamos un fichero de configuración de apache. En este ejemplo, nuestra aplicación se llamará «app1»:

$ sudo vim /etc/apache2/sites-available/app1

Y escribimos:

WSGIScriptAlias /app1 /var/www/app1/app1/apache/django.wsgi
<Directory /var/www/app1/app1/apache>
    Order allow,deny
    Allow from all
</Directory>

A continuación, generamos el WSGI alias script para app1:

$ sudo vim /var/www/app1/app1/apache/django.wsgi

Vamos a /var/www/ y creamos dentro el script WSGI:

$ cd /var/www
$ django-admin.py startproject app1
$ mkdir /var/www/app1/app1/apache
$ sudo vim django.wsgi

Introducimos el contenido del script, para ello escribimos:

import os, sys
sys.path.append('/var/www/app1/')
os.environ['DJANGO_SETTINGS_MODULE'] = 'app1.settings'

import django.core.handlers.wsgi

application = django.core.handlers.wsgi.WSGIHandler()

Ejecutamos a2ensite:

$ sudo a2ensite

Nos pedirá el nombre de la aplicación. Escribimos:

app1

Y finalmente reiniciamos apache:

$ sudo /etc/init.d/apache2 restart

Y listo, listísimo.

Ahora podéis acceder a esta aplicación desde http://misitio.ugr.es/app1.
Hasta la próxima.

Correr scripts en Perl como un ejecutable

Un simple pero muy útil y eficiente truco es crear una carpeta ~/bin donde añadir binarios de programas y así ejecutarlos rápidamente sin tener que ir a la localización de los mismos como expliqué aquí.

En el caso de que se trate de un script en perl tenemos que modificar el fichero. Si se encuentra en la carpeta bin, debemos de comprobar que la primera línea resulta ser al como esto.

#! /usr/bin/perl

Puede ocurrir que no tenga permisos de ejecución, para dárselos bastaría con hacer en consola:

$ chmod +x script.pl

Así de fácil. Así de útil.

 

 

[Bioinformática] DendroPy: Librería para análisis filogenético. Árbol consenso MrBayes

La informática tiene sus misterios, o tal vez yo soy lo suficientemente avispado como para escudriñar hechos que aparentemente no tienen lógica. Resulta que tras correr una larga simulación para realizar una inferencia filogenética bayesiana con MrBayes, el software era incapaz de realizar la filogenia consenso con la misma orden que comúnmente he ido utilizando desde que aprendí a correr el programa.

Buscando soluciones, me topé con DendroPy, una librería escrita en Python para análisis filogenético.

Para instalarlo, puedes utilizar uno de estos dos comandos.

$ sudo pip install dendropy

con utilizando setuptools:

$ sudo easy_install -U dendropy

Si todo ha marchado correctamente, podremos utilizar SumTrees, el programa de la librería apropiado para realizar una filogenia consenso con los resultados de MrBayes.

Por ejemplo, para tener un resumen de la probabilidad posterior en la filogenia, la línea sería esta:

$ sumtrees.py --min-clade-freq=0.95 --burnin=200 --support-as-labels --output=result.tre treefile1.tre treefile2.tre treefile3.tre

Gracias a esto logré aprovechar ese análisis. Siempre Python.

[Bioinformática] abifpy: Módulo de Biopython para leer ficheros ABI *.ab1

Llevaba tiempo buscando alguna manera de introducir secuencias en formato abi en Biopython. Este formato contiene las lecturas del secuenciador así que no solo tenemos la información de la secuencia sino de la calidad o el nivel de confianza de dada una de las bases secuenciadas.

El módulo de Biopython se llama Abifpy y está disponible para descargar libremente desde el Github del autor. Una manera de instalarlo es introducir la ruta del módulo en el fichero ~/.bashrc:

# Add custom Python modules to the Python path.
PYTHONPATH=$PYTHONPATH:~/abifpy
PYTHONPATH=$PYTHONPATH:~/usr/lib/python2.6/site-packages
export PYTHONPATH

Ahora al iniciar  Python deberíamos tener el módulo operativo. La forma de uso es muy sencilla:

$ python
>>> import abifpy
>>> secuencia = abifpy.Trace(«file.ab11») # abrir fichero
>>> secuencia = abifpy.Trace(«file.ab1», trimming=True) # abrir fichero y quitar los extremos de la secuencia, de menor calidad
>>> secuencia.seq # ver secuencia
>>> secuencia.qualVal # ver valores de calidad de cada secuencia
>>> secuencia.name # nombre de la secuencia

Fácil, ¿verdad? Pues tan más útil resulta.

Pyploma: Generador de diplomas en LaTeX a partir de una lista de datos

ACTUALIZACIÓN 14/9/2012: He desarrollado una versión de Pyploma con GUI. Si estás interesado en probarla, visita el repositorio del proyecto en Github.

Durante los últimos meses he participado en la organización de un ciclo de conferencias en la facultad. Una vez finalizado y tras la evaluación de los asistentes era el momento de realizar los diplomas. Los habituales lectores de este humilde blog ya sabréis que soy amante de las soluciones elegantes, así que me lancé a escribir un programita que generara los diplomas en formato LaTeX de forma automática y luego los compilara a pdf.

Pyploma es un script que, por supuesto, está escrito en python que coge un fichero LaTeX que contiene unos marcadores comentados y añade una serie de datos para cada entrada de una lista de datos. Aunque está originalmente pensado para generar diplomas, sustituyendo el dichero LaTeX podría servir para autorrellenar cualquier otro tipo de documento, incluso si está escrito en otro lenguaje.

Para que compile a pdf necesita tener instalado LaTeX y para unir los pdfs en un fichero depende de pdftk. No obstante estas funciones son opcionales y pueden comentarse en el script.

Hacerlo funcionar es tan sencillo como modificar en el script el nombre de la plantilla LaTeX y el de la lista de datos. Después escribir:

$ python pyploma.py

Y listo. Parece magia, pero no, es Python. Para ver el resultado, esta es la salida.

Si quieres descargar la plantilla LaTeX, la lista de datos y el script, sigue este enlace.

Plantilla LaTeX

\documentclass[12pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[spanish]{babel}
\usepackage{mathpazo}
\renewcommand{\familydefault}{\rmdefault}
\usepackage[landscape,a4paper]{geometry}
\geometry{verbose,tmargin=0cm,bmargin=0cm,lmargin=0cm,rmargin=0cm}
\usepackage{fancybox}
\usepackage{calc}
\usepackage{multicol}
\usepackage{graphicx}

\begin{document}
~
\vspace{1cm}
\begin{center}

\huge{Un Bioinformatiquillo (https://bioinformatiquillo.wordpress.com)\\ certifica que}

\vspace{1cm}

\Huge{\textbf{%pointname

}}

\vspace{1cm}

\Large{con D.N.I. no.%pointdni

ha asistido y superado los estudios\\ con una califiaci\'on de %pointcalification

en el}

\vspace{1cm}

\Huge{\textbf{I CURSO DE REALIZACIÓN DE DIPLOMAS CON PYPLOMA}}

\vspace{1cm}

\Large{celebrado el 6 de julio de 2011 vitualmente en el blog, con una duraci\'on de un ratillo}

\vspace{.5cm}

\Large{Y para que as\'i conste se expide el siguiente certificado en el ciberespacio a \today.}

\vspace{.5cm}

\begin{multicols}{3}

\small Delegado de asusntos LaTeros\\
\vspace{3cm}
León Delátex Pérez
%\vspace{1cm} 

Director de Pythonismo\\
\vspace{3cm}
Ser Piente Grande
%\vspace{1cm} 

El/La Alumno/a\\
\vspace{3cm}
~~~~~~~~~~

\end{multicols}

\tiny El blog Un Bioinformatiquillo, con domicilio en el Vía Láctea s/n

\end{center}
\end{document}

Script en Python

Periquillo de los Palotes	00000001-A	NOTABLE
Rodolfo Chiquilicuatre	000000002-B	SOBRESALIENTE
Chavo del Ocho	00000003-C	APROBADO

Script en Python

# -*- coding: utf-8 -*-
# Este generador de diplomas lee una lista con nombre, dni y calificación para
# rellenarlos en una plantilla LaTeX con un marcador para cada campo.
# Opcionalemente compila los ficheros LaTeX generados y los une en uno solo.
# Si la plantilla LaTeX da error de compilación, pulsar intro varias veces.

print "Pyploma: Generador de diplomas en formatos LaTeX y pdf.\n"

# Invocar al terminal
from commands import *
import commands
def run_command(cmd):
    getstatusoutput(cmd)

# Cargar lista de nombres
lista = open("listadip", "r").readlines()

#contador
a = 100

for line in lista: # para cada persona...

    a += 1 #contador
    b = str(a) #pasa el contador a cadena
    salida = open("output" + b + ".tex","w") # crea fichero LaTeX para cada persona
    person = line[0:-1].split("\t") # pasar la cadena en lista

    text = open("certi.tex") # abrir documento LaTeX
    text = text.read() # leer documento LaTeX
    text_list = list(text) # pasa a lista

    y_cali = text.find("%pointcalification") # busca marcador de calificación
    z_cali = len("%pointcalification")+1
    text_list[y_cali+z_cali:y_cali+z_cali] = list(person[2]) # inserta calificación

    y_dni = text.find("%pointdni") # lo mismo para el dni
    z_dni = len("%pointdni")+1
    text_list[y_dni+z_dni:y_dni+z_dni] = list(person[1])

    y_name = text.find("%pointname") # lo mismo para el nombre
    z_name = len("%pointname")+1
    text_list[y_name+z_name:y_name+z_name] = list(person[0])

    text_final = "".join(text_list) # de lista a cadena

    salida.write(text_final) # guarda los cambio en el fichero creado
    salida.close() # cierra el fichero creado

    run_command(str("pdflatex " + "output" + b + ".tex")) # compila el fichero LaTeX a pdf (opcional)
    print person[0] #control

run_command(str("pdftk output*.pdf cat output todos_diplomas.pdf")) # crea pdf con todos los diplomas creados (opcional)

print "\n¡FINAL DE LA OPERACIÓN!" #control

[Bioinformática] Convertir entre formatos de lecturas de secuenciación masiva: SRA, FASTQ y FASTA

Esta tarde me ha dado por curiosear cómo se utilizan ciertos programas para ensamblar lecturas de secuenciación masiva, concretamente obtenidas con Illumina y que se encuentran en bases de datos. Concretamente quería correr SOAPdenovo. No por nada, solo por curiosidad, pues la ejecución de software para este fin requiere de máquinas con muchos recursos. El caso es que como formato de entrada me pedía FASTQ y sin embargo me los descargué en SRA.

Es muy sencillo, si sabes cómo, realizar esta operación. Basta con ir a la página descargas de SRA Toolkit y obtener la versión para Ubuntu. Tras descomprimir, abrirmos un terminal en la carpeta y  ejecutamos fastq-dump de la siguiente manera (no es necesario instalar nada):

$ ./fastq-dump [--gzip] -A SRRxxxxxx -M 0 --split-files /ruta/fichero/SRRxxxxxx.sra

Así, después de un rato de procesamiento, obtendremos un fichero FASTQ.

Alternativametne, si queremos cambiar las etiquetas de las lecturas, podemos utilizar un comando como el siguiente, aunque es más lento:

$ ./fastq-dump --defline-qual '+' --defline-seq '@SRRxxxxxxx_$sn[_$rn]/$ri' --split-files SRRxxxxxxx.sra

Este es un fichero que puedes abrir un cualquier editor de textos (por ejemplo gEdit), pero si quieres pasarlo a formato FASTA, puedes pedir que te ayude BioPython. Si no lo tienes instalado:

$ sudo aptitude install python-biopython

Ejecutamos el interprete python (o ipython mejor) y ejecutamos el comando para convertir el formato del fichero:

$ python
>>> from Bio import SeqIO
>>> SeqIO.convert("example.fastq", "fastq", "example.fasta", "fasta")

Con esto debería bastar. Hala, ya tenemos nuestros ficheros con gigas de información para ser analizados. Pero hoy ya estoy muy cansado…

————————————————————————————————-

ACTUALIZACIÓN 19/05/2011

Script Python para automatizar conversión FASTQ a FASTA a partir de una lista de ficheros.

from Bio import SeqIO

seq = open("files.txt", "r").readlines()

for line in seq:
    a = list(line)
    b = a[:-1]
    c = "".join(b)
    print "Empezando %s" % c
    SeqIO.convert(c, "fastq", c+".fas", "fasta")
    print "Terminado %s, a por el siguiente!!!" % c

print "TODO FINALIZADO"

Integrar Meld en Gedit: Comparación rápida de ficheros

Fuente: MuyLinux

Meld es y buscar diferencias entre dos versiones distintas del mismo archivo, pero solo se puede usar para eso y no es especialmente válido para la programación directa. Por otro lado, gedit es un gran editor de textos que también sirve para programar pero no dispone de la capacidad de comparar ficheros, así que… ¿Por qué no unirlos a los dos?

Es lo que nos cuentan en WebUpd8, donde indican una sencilla forma de integrar Meld en gedit aunque de una forma no exactamente directa: no lograremos contar con una funcionalidad directa de comparación en gedit, sino que podremos comparar el fichero que estamos viendo en gedit con otro fichero que se abrirá en Meld.

Para lograr este propósito tendremos que tener instalados tanto Meld como Zenity:

sudo apt-get install meld zenity

En gedit tendremos que ir a Editar -> Preferencias y en la pestaña de plugins tendremos que habilitar el plugin de las “External tools” (“Herramientas externas”). Allí tendremos que pinchar en “Configure Plugin” (“Configurar Plugin”), añadir una nueva herramienta externa (con el botón “+”), darle un nombre cualquiera (por ejemplo, “Comparar con Meld”), y si queremos establecer un atajo de teclado. Por último, antes de acabar, queda por escribir lo siguiente bajo el campo “Edit“:

#!/bin/sh
meld $GEDIT_CURRENT_DOCUMENT_DIR/$GEDIT_CURRENT_DOCUMENT_NAME `zenity --file-selection --title="File for comparsion" --filename=/home/` &

De ese modo cuando presionemos el atajo de teclado establecido por nosotros o vayamos a Herramientas -> Herramientas externas -> Comparar con Meld se abrirá una ventana de Zenity pidiéndonos el fichero que queremos comparar con el que estamos viendo en gedit.

Python-getopt: Script para ser ejecutado con argumentos

Aquí va otro post sobre las cosillas que últimamente he ido aprendiendo. Esta vez toca desarrollar un script para ser ejecutado con argumentos. Resulta que estoy poniendo a punto un script para luego crear una interfaz web con Python-Django donde quiero que el usuario seleccione unas funciones sí y otras no. Para testear esto decidí implentar selección e argumentos para que fuera ejecutado tal que así:

$ python myscript.py -a -t

$ python my script.py -t -z

Me he ayudado de la librería getopt. Sé que es un poco rudimientario de momento, pero me ha hecho el apaño. Parece ser que argparse es un módulo mejorado, aunque no le he metido mano. No obstante, si alguien conoce otra manera o tiene alguna sugerencia, por favor, que avise.

Bien, en primer lugar debemos importar los módulos necesarios:

import sys, getopt, os

Después definimos una función donde describiremos los argumentos:

try:
	opts, args = getopt.getopt(sys.argv[1:], "abc:dh", ["funcion1", "funcion2", "funcion3", "funcion4", "help"])
except getopt.GetoptError, err:
	# print help information and exit:
	print str(err) # will print something like "option -a not recognized"
	usage()
	sys.exit(2)

En este caso a,b,c,d y e son nuestros argumentos y seguidamente aparece el nombre de la función a la que hacen la llamada conocadas en el mismo orden que los argumentos. Los «:» que aparecen despues de «c» significan que reguiere un argumento adicional para llamar a la función como puede ser el nombre de un fichero. En estas líneas además, vemos que si no se introduce ningún argumento, salta un mensaje de error (definido por usage()) y se corta el script. Dicho mensaje se puede definir de esta forma:

def usage():
	print """
NOMBRE
\t MyScript - Es la leche\n
MODO DE EMPLEO
\t python caipyranha.py [-a] [-b] [-c] [-d] [-h]\n
\t Los nombres de los ficheros y carpetas deben ir sin espacios.\n
\t Se debe respetar el orden marcado arriba excepto para la opción -b, pudiéndose saltar alguna
\t opción excepto -e.\n
\t Debe indicar la pareja de primers utilizada para amplificar el producto.\n
\t Debe indicar el intervalo de la etiqueta que quiere utilizar para hacer comparaciones.\n
OPCIONES
\t -a \t Realiza la función 1
\t -b \t Realiza la función 2
\t -c \t Realiza la función 3
\t -d \t Realiza la función 4
\t -e \t Abre esta guía de ayuda
"""

Ahora que tenemos esto definido, vamos a indicar las funciones que ejecuta cada argumento:

for o, a in opts:
	if o in ("-h", "--help"):
		usage()
		sys.exit()
	elif o in ("-a", "--afuncion"):
		for sequencia in lista_files:
			funcion1(str(sequencia))
		print "\n\n Función 1 realizada"
	elif o in ("-b", "--bfuncion"):
		funcion2()
		print "\n\n Función 2 realizada"
	elif o in ("-c", "--cfuncion"):
		funcion3()
	elif o in ("-d", "--dfuncion"):
		funcion4()
	else:
		assert False, "error"

Y con estoy bastará para que tengamos a punto nuestro script para que se ejecute con argumentos.

Más información | getopt y argparse

RUR-ple: Python para que aprendan los más pequeños

Fuente: UbuntuLife

RUR-ple es una aplicación para enseñar a programar en Python. Evidentemente no servira a los más veteranos que quieran un IDE o un tutor más complejo, ni éste es el objetivo de la aplicación, su uso está más destinado para niños a los que se quiera ir enseñando las instrucciones y sentencias de control de flujo básicas de un lenguaje de programación. Desde la aplicación podremos construir un laberinto con muros (planteando de ésta manera diferentes ejercicios) y el niño debera programar el código correspondiente para manejar al robot de la pantalla y escapar del laberinto. Recomiendo leer la fantastica ayuda en html que viene incluida en la que se comenta mejor el funcionamiento de la aplicación y plantea diferentes y pequeños ejercicios para ir avanzando en el uso de la aplicación.

Para instalarlo, podeis descargar un paquete .deb desde el siguiente enlace. Una vez instalado, Para iniciar podemos entrar en el directorio:

$ cd /opt/rur-ple

y ejecutar:

$ ./rur_start.py

Via | BarraPunto

rpy2: Ejecutando R desde Python

En el post anterior expliqué cómo realizar filogenias con el paquete R. Pero no me bastaba con aprender esto, sino que quería integrar órdenes de  R en un script en Python, del mismo modo que se puede integrar R con LaTeX gracias a Sweave. Y claro que se puede, con rpy2, un proyecto que nos proporciona una sintaxis para trabajar con R desde Python.

Es un proyecto que se encuentra en una fase de rápido desarrollo y que conviene tener la última versión, pues hay notables mejoras. Por eso en lugar de instalar desde repositorios el paquete «python-rpy2», recomiendo hacerlo por un precompilado deb desde launchpad. Yo me he instalado la versión de Maveric en Lucid y no he notado ningún problema.

Una vez salvado este punto, pasamos a la acción. Ejecutamos el interprete Python y cargamos rpy2:

>>> import rpy2.robjects as robjects

A continuación parte del código utilizado en el post anterior con objeto de dibujar un árbol filogenético:

>>> robjects.r.library("ape")
>>> robjects.r.library("phangorn")
>>> robjects.r.library("multicore")

>>> data = robjects.r["read.dna"]("alignment_contig_phy.txt")
>>> data = robjects.r["as.phyDat"](data)
>>> data = robjects.r["as.DNAbin"](data)

>>> print(data)

>>> dm = robjects.r["dist.dna"](data, model = "JC69")
>>> treeUPGMA = robjects.r["upgma"](dm)
>>> viewUPGMA = robjects.r["plot"](treeUPGMA)

Y se nos abrirá la ventana con nuestro árbol. Nota que la sintáxis es sencilla. El nombre de la función R entre corchetes y comiilas seguido de los datos a los que se aplican entre paréntesis. Esto, precedido de «robjects.r», la función de rpy2 que hace las llamadas a R. Esto es todo por el momento, más información en la documentación de la librería.

Así de fácil, así de R, así de Python.