Bitácora de Vuelo (Publicaciones sobre compilar)

Usando Go desde Python

Facundo Batista — Mon, 09 Oct 2017 21:20:23 GMT

¿Alguna vez necesitaron usar un código de Go desde Python? Yo sí, y acá cuento qué hice.

Antes que nada, un poco de background, para que el ejercicio no sea demasiado teórico: en el laburo tenemos que validar las licencias que se incluyen en el .snap, y aunque el formato en que están sería estándar (SPDX), una condición de contorno es usar el mismo parser/validador que se usa en snapd, para estar 107% seguros que el comportamiento va a ser el mismo hasta en los corner cases o bugs.

El detalle es que snapd está escrito en Go, y el server está escrito en Python. Entonces tengo que compilar ese código en Go y usarlo desde Python... de allí este post, claro.

Es más fácil de lo que parece, ya que el compilador de Go tiene la capacidad de buildear a "biblioteca compartida", y de ahí usarlo desde Python es casi trivial ("casi", porque tenemos que poner algo de código en C).

Para ser más claro, si queremos ejecutar "la lib de SPDX hecha en Go" desde nuestro Python, tenemos que poner dos componentes, que funcionan casi de adaptadores:

Un pequeño código en C para armar "como módulo" una funcioncita que recibe y entrega objetos Python, y hace la traducción al "mundo C" y llama a otra función en Go.
Un pequeño código en Go que traduce los parámetros desde C y llama a la biblioteca SPDX correspondiente.

Adaptador de Python a C

El archivo completo es spdx.c, paso a explicarlo haciendo antes la aclaración que es para Python 2 (que es lo que tenemos hoy en ese servicio), pero si fuera para Python 3 sería muy parecido (la idea es la misma, cambian algunos nombres, revisen acá).

Antes que nada, incluir la lib de Python:

#include <Python.h>

Vamos a llamar a una función de Go, necesitamos explicitar lo que va recibir (una cadena de bytes, que a nivel de C es un puntero a chars) y lo que nos devuelve (un número, que interpretaremos como bool):

long IsValid(char *);

Definimos la función que vamos a llamar desde Python... es sencilla porque es genérica, recibe self y argumentos, devuelve un objeto Python:

static PyObject *
is_valid(PyObject *self, PyObject *args)

El cuerpo de la función es sencillo también. Primero definimos 'source' (el string con la licencia a validar) y 'res' (el resultado), luego llamamos a PyArg_ParseTuple que nos va a parsear 'args', buscando una cadena ('s') la cual va a poner en 'source' (y si algo sale mal nos vamos enseguida, para eso está el 'if' alrededor):

{
    char * source;
    long res;

    if (!PyArg_ParseTuple(args, "s", &source))
        return NULL;

Finalmente llamamos a IsValid (la función en Go), y a ese resultado lo convertimos en un objeto de Python tipo bool, que es lo que realmente devolvemos:

    res = IsValid(source);
    return PyBool_FromLong(res);
}

Ahora que tenemos nuestra función útil, debemos meterla en un módulo, para lo cual tenemos que definir qué cosas van a haber en dicho módulo. Entonces, armamos la siguiente estructura, con dos lineas; la primera habla sobre nuestra función, la última es una marca en la estructura para que sepa que es el final:

static PyMethodDef SPDXMethods[] = {
    {"is_valid", is_valid, METH_VARARGS, "Check if the given license is valid."},
    {NULL, NULL, 0, NULL}
};

En la linea útil tenemos:

"is_valid": es el nombre de la función que vamos a usar desde afuera del módulo
is_valid: es una referencia a la función que tenemos definida arriba (para que sepa qué ejecutar cuando llamamos a "is_valid" desde afuera del módulo.
METH_VARARGS: la forma en que recibe los argumentos (fuertemente atado a como luego los parseamos con PyArg_ParseTuple arriba.
"Check ...": el docstring de la función.

Para terminar con este código, va el inicializador del módulo, con un nombre predeterminado ("init" + nombre del módulo), y la inicialización propiamente dicha, pasando el nombre del módulo y la estructura que acabamos de definir arriba:

PyMODINIT_FUNC
initspdx(void)
{
    (void) Py_InitModule("spdx", SPDXMethods);
}

Adaptador de C a Go

El archivo completo es spdxlib.go.

Tenemos que meter el código en un paquete 'main':

package main

Importamos el código para SPDX de snapd (tienen que bajarlo antes con go get github.com/snapcore/snapd/spdx):

import "github.com/snapcore/snapd/spdx"

Importamos adaptadores desde/a C, indicando que cuando buildeemos vamos a usarlo desde Python 2:

// #cgo pkg-config: python2
import "C"

La función propiamente dicha, donde indicamos que recibimos un puntero a char de C y vamos a devolver un bool:

//export IsValid
func IsValid(license *C.char) bool {

El cuerpo es nuevamente sencillo: llamamos al ValidateLicense de SPDX (convirtiendo primero la cadena a Go), y luego comparamos el resultado para saber si la licencia es válida o no:

    res := spdx.ValidateLicense(C.GoString(license))
    if res == nil {
        return true
    } else {
        return false
    }
}

Cerramos con la definición obligatoria de main:

func main() {}

Lo usamos

Primer paso, buildear (yo tengo Go 1.6, creo que necesitan 1.5 o superior para poder armar directamente la biblioteca compartida de C, pero no estoy seguro):

go build -buildmode=c-shared -o spdx.so

Segundo paso, profit!

$ python2
>>> import spdx
>>> spdx.is_valid("GPL-3.0")
True

Tipográfica y ffmpeg

Facundo Batista — Mon, 24 Dec 2007 18:47:32 GMT

El otro día, por una remera en la que mi hermana imprimió un grabado de su autoría, fuimos con ella, Moni y Gus a la imprenta de este último.

Curioseamos bastante, y entre todo lo que Gustavo mostró, estaba su impresora tipográfica automática. Ya no la usa mucho, pero la prendió y la hizo funcionar para mostrarnos cómo trabajaba. Aproveché y la filmé con el teléfono:

Pero no fue todo tan fácil. El video que generé con el fono, en la computadora no lo podía ver bien. Bah, se veía bien, pero salía sin sonido. Yo lo quería pasar a un formato más estándar, justamente para subirlo a Google Videos.

En todos los lugares que busqué, siempre recomendaban utilizar el ffmpeg, así que lo instalé de la forma normal (con el Synaptic, haciendo cuatro clicks), pero tampoco entendía el audio.

Seguí buscando, hasta que encontré que, para que reprodujera bien el formato 3gp, debía compilar el ffmpeg con las bibliotecas de AMR. No fue demasiado complicado, pero tampoco fue recontra sencillo, así que reproduzco los pasos acá, que fueron más que nada el producto de seguir tres o cuatro guias sueltas por ahí.

Si arrancamos con un Ubuntu crudo, les va a faltar lo necesario para compilar (creo que con instalar el paquete build-essential deberían tener todo lo necesario).

Creamos y nos metemos en un directorio para todo este experimento:

mkdir locoffmpeg
cd locoffmpeg

El proyecto ffmpeg no tiene liberaciones estables, sino que normalmente se utilizan directamente los archivos de desarrollo. Para que no tengan que hacer un checkout del repositorio, pueden utilizar el snapshot que se genera todas las noches; lo bajamos y descomprimimos:

wget http://ffmpeg.mplayerhq.hu/ffmpeg-export-snapshot.tar.bz2
tar -jxf ffmpeg-export-snapshot.tar.bz2

Traemos las fuentes de la biblioteca para AMR Narrow Band, la descomprimimos, vamos a ese directorio, la configuramos, compilamos e instalamos:

wget http://downloads.sherin.in/sources/amrnb-7.0.0.0.tar.bz2
tar -jxf amrnb-7.0.0.0.tar.bz2
cd amrnb-7.0.0.0/
./configure --prefix=/usr
make
sudo make install
cd ..

Exactamente lo mismo, pero para la AMR Wide Band:

wget http://downloads.sherin.in/sources/amrwb-7.0.0.2.tar.bz2
tar -jxf amrwb-7.0.0.2.tar.bz2
cd amrwb-7.0.0.2
./configure --prefix=/usr
make
sudo make install
cd ..

Dos detalles.

En ambos make, el tipo baja un pequeño archivo de algún lado, así que tienen que estar conectados a internet.
Fíjense que el make install tiene un "sudo" adelante; esto es porque necesitan permisos de root para instalar la biblioteca.

Luego entramos al directorio donde tenemos el ffmpeg descomprimido (el * en la primer órden aquí es porque el nombre del directorio depende del día, hagan un ls -l y lo van a ver).

cd ffmpeg-export-*

Una vez adentro, configuramos el ffmpeg para que se instale en /usr/local (con lo que si tienen otra versión de ffmpeg instalado no lo van a pisar), y le habilitamos threading y las dos bibliotecas que nos interesan:

./configure --prefix=/usr/local --enable-pthreads --enable-libamr-nb --enable-libamr-wb
make
sudo make install

Ya tenemos el ffmpeg alternativo que compilamos, entonces transformamos el video del fono a algo estándar (en este caso, el video del fono se llama MOV00001.3gp, y dejamos el video nuevo en video.avi).

/usr/local/bin/ffmpeg -i MOV00001.3gp -acodec mp2 -ar 44100 -vcodec mpeg4 video.avi

¡Ya está! El paso final fue subirlo a Google Video, pero eso se lo dejo a ustedes.