Highlights de la ESA de 2015

Ya ha salido el tradicional resúmen del año de la ESA.

Notebooks jupyter en pdf via pandoc

Para poder controlar todos los detalles de la impresión de los notebooks de jupyter, podemos volcarlos primero a formato markdown y de ahí convertirlos a tex o pdf via pandoc. En general, el paso a pdf funciona muy bien con la plantilla article pero siempre hay detalles que podemos modificar en el tex que se genera de intermedio.

Si queremos que pandoc nos genere el pdf directamente, hacemos

``` convert.sh
jupyter nbconvert --to markdown $1.ipynb
pandoc $1.md -s -o $1.pdf
```

Si queremos volcar antes a tex para editarlo

``` convert_tex.sh
jupyter nbconvert --to markdown $1.ipynb
pandoc $1.md -f markdown -t latex -s -o $1.tex
```

En realidad esto debería generar el mismo tex que exportar directamente desde jupyter.

Personalizar manualmente el documento latex que genera pandoc

Podemos personalizar el documento tex es añadiendo algunos comandos adicionales.

Idioma

En la cabecera del documento

\usepackage[catalan]{babel}

Título del documento

Justo antes del begin document

\title{Títol del document \\ Autor: Pere Vilás}

y justo después

\begin{document}

\maketitle

\tableofcontents    

La razón de tener que poner el título a mano es que sale como sección y queda mal en el índice.

Imágenes

Las imágenes salen del markdown sin tamaño, así que hay que ir una por una añadiendo el width o la scale. También se puede aprovecha para cambiar el caption:

\begin{figure}[htbp]

\centering

\includegraphics[width=75mm]{X1.jpg}

\caption{X1}

\end{figure}

Saltos de página

Algunas veces las imágenes u otros elementos no quedan bien colocados, generalmente sólo hay que introducir algún final de página para que queden en su sitio.

\newpage

Usar metadatos de pandoc

Este método de personalización es más automático que el anterior y no hay que editar el tex. Consiste en editar el markdown para añadir la cabecera al principio del documento. Las cabeceras de metadatos de makdown están en formato yaml y lucen tal que así (hay que poner las tres rayas de inicio y final):

``` cabecera del documento markdown

---

title: Título del documento

author: Pepe Pérez

header-includes:

    - \usepackage[utf8]{inputenc}

    - \usepackage[catalan]{babel}

    - \usepackage{fancyhdr}

    - \pagestyle{fancy}

    - \rhead{Universidad a distáncia}

    - \lhead{Asignatura xxxx}

    - \rfoot{\thepage}

    - \fancyfoot[CO,CE]{Prueba3}

toc:

    true

---

```

Estos metadatos instruyen a pandoc para formatear el documento de salida. De esta forma podemos generar el pdf personalizado directamente a partir del md con

pandoc doc.md -o doc.pdf

Personalización máxima de la salida de pandoc

También podemos modificar directamente la plantilla de pandoc personalizándola según nuestros intereses. Primero hacemos una copia de la plantilla por defecto con

pandoc -D latex > plantilla.tex

Personalizamos la plantilla y generamos el pdf 

pandoc -s -N --template=plantilla.tex doc.md -o doc.pdf

Python simbólico resolver ecuación

Resolver esta ecuación en wolfram alpha,

... y su equivalente usando sympy



>>> from sympy import symbols, var
>>> v1,v2,v3,vo,r1,r2,r3,r4,rf=symbols('v1,v2,v3,vo,r1,r2,r3,r4,rf')

>>> from sympy.solvers import solve

>>> from sympy import init_printing

>>> init_printing(use_unicode=False, wrap_line=False, no_global=True)

>>> solve(v1/r1 + v2/r2 - ((v3*(r4/(r3+r4)))-vo)/rf, vo)

 r1*r2*r4*v3 - r1*r3*rf*v2 - r1*r4*rf*v2 - r2*r3*rf*v1 - r2*r4*rf*v1 

[-------------------------------------------------------------------]

                           r1*r2*(r3 + r4)                 

Django modelo de datos genérico usando abstract

Habitualmente, tenemos los mismos campos en varias tablas (modelos); Por ejemplo, la descripción, la fecha de alta, la fecha de última modificación, etc. Una forma de representar esto en los modelos es usar una clase genérica con los campos comunes y darle el atributo abstract. Las clases derivadas heredarán esos atributos.

El la sincronización, Django no creará ninguna tabla en la base de datos si está marcada como abstract.

En cuanto al nombre de la clave primaria del modelo, particularmente prefiero darle nombre en vez de dejar que Django la nombre como id.

Hay que ir con cuidado derivando modelos: No es lo mismo una tabla (o una entidad) derivada que una vista. Por ejemplo, podríamos tener una entidad llamada Persona y otras derivadas llamadas Cliente, Proveedor, Agente, Transportista, etc. Si en Django derivamos esos modelos directamente de un modelo base (Persona), en la base de datos se crearán tantas tablas nuevas como modelos derivados (Clientes, Proveedores, ...). Esto no tiene nada que ver con tener una tabla llamada Persona y diversas vistas de esa única tabla llamadas Clientes, Proveedores, etc. En Django cada modelo equivale a una tabla (entidad), no a una vista. Para crear el equivalente a una vista debemos usar un QuerySet.



```python

# -*- coding: utf-8 -*-
from django.db import models

LENGHT_DESC=150 # longitud de las descripciones
H_DESC = 'Entre descripción'

def cPk():
    # devuelve clave primaria
    return models.AutoField(primary_key=True)

def cFum():
    # devuelve fecha ultima modificación
    return models.DateTimeField(auto_now=True, null=False, blank=False)

def cDesc(ml=LENGHT_DESC, df=''):
    # devuelve descripción
    return models.CharField(max_length=LENGHT_DESC, help_text=H_DESC, null=False, blank=False, default= df)

def cFechaAlta():
    # fecha de alta del registro
    return models.DateTimeField(auto_now_add=True, null=False, blank=False)

class ModBase(models.Model):
    #
    # modelo base con descripcion, fecha de alta y fecha última modificación
    #
    descipcion=cDesc()
    fecha_alta=cFechaAlta()
    fum=cFum()

   

    class Meta:

        abstract=True

# esta tabla tendrá todos los campos de ModBase más los propios

class Personas(ModBase):

    # el nombre de la clave primaria es persona

    persona=cPk()

```    

También podríamos usar la el modelo base para hacer un logger de los cambios en la base de datos, apuntando el nombre de la tabla, operación, usuario, etc.

Virtualenv python3 django

sudo apt-get install python-virtualenv
cd ~
virtualenv -p python3 env_django
source ~/env_django/bin/activate
pip install Django==1.8.6


Para MacOS este tutorial incluye información de cómo configurar pyvenv.

brew install python3
python3 --version
pip install --upgrade pip
pip install virtualenv
pip install virtualenvwrapper
mkdir ~/.virtualenvs
vi ~/.bashrc
--> Añadir:
export WORKON_HOME=~/.virtualenvs
source /usr/local/bin/virtualenvwrapper.sh
--<
source .bashrc
--> buscar directorio de python3 con
which python3
mkvirtualenv --python=python3_path env-django
--> ya tenemos el entorno con python3 activado
deactivate
workon env-django
pip install Django==1.9

Instalar LaTeX y pandoc en Ubuntu

Desde el software center, instalar TexMaker

Para instalar  packages

sudo apt-get install xzdec
tlmgr install nombre_paquete


Opcionalmente, para los paquetes de idiomas de babel

sudo apt-get install texlive-lang-spanish
sudo apt-get install texlive-lang-european

Probar

\documentclass[10pt,a4paper]{article}

\usepackage[utf8]{inputenc}

\usepackage[spanish]{babel}

\usepackage{amsmath}

\usepackage{amsfonts}

\usepackage{amssymb}

\author{Pere Vilás}

\begin{document}

dddd

\end{document}

Para instalar pandoc

sudo apt-get install cabal-install

cabal update
PATH=$HOME/.cabal/bin:$PATH
cabal update
cabal install alex happy
sudo apt-get install libghc-zlib-dev  libghc-zlib-bindings-dev
cabal install pandoc pandoc-citeproc
pandoc --version

Aplicaciones web de gestión con Oracle JET. ¿Porqué no habías salido antes?

Oracle acaba de sacar su framework JET para la creación de front-end de aplicaciones web usando Javascript.

Me figuraba que sería otro de los "tochos" de esta empresa, con documentación críptica y montones de manuales por leerse. Nada de eso: El producto va como como la seda. Con JET se pueden empezar aplicaciones con un par de clicks, sabiendo que estás sobre un framework muy bien estructurado y que te quita la mayoría de dolores de cabeza típicos de una aplicación de gestión.

Una vez descargada la plantilla, sólo hay que hacer copia-pegar de las "recetas" que cubren una gran cantidad de supuestos de uso o "patterns" que nos encontramos en este tipo de aplicaciones. La plantilla está diseñada para que el código esté ordenado y sea fácil de mantener.

Está basado sobre código abierto (aunque JET no lo es al 100% de momento). Usa, entre otros, jquery y knockout para la sincronización.

Las plantillas vienen por defecto con mobile first, lo que nos ahorra tener que pensar también en el aspecto del renderizado en múltiples plataformas.

Para aplicaciones de gestión es especialmente interesante el apartado de Data collections, podemos asociar los UI widgets a nuestras fuentes de datos de forma bastante fácil.

Sólo necesitamos un sencillo servidor web corriendo en la raiz del proyecto para poder trabajar.

A diferencia de otros frameworks más especializados, JET decide un montón de cosas del front de tu aplicación. El aspecto, menús,  interacción,... Esto puede ser bueno si lo que necesitas es concentrarte en el backend.

Lo que me gusta es que trabajas con él de la misma forma en que tú ya estás trabajando: Cuando necesitas algo, lo buscas, le haces copiar-pegar y lo adaptas a tu necesidad.

El contar con el respaldo de una empresa como Oracle también es un tanto a favor en cuanto a la estabilidad y mantenimiento del framework. Oracle quiere meterse en las tablets y los móviles y me da la impresión de que por este camino, ayudando a los desarrolladores, va a conseguirlo.

No es para nada casualidad que hace poco Oracle creaba su centro de soporte para Node y sacara los drivers oficiales (node-oracledb) para conectar este con su gestor de base de datos. La apuesta de Oracle por Javascript y el mobile va muy en serio.