Conding News

Boletín oficial analizado con CoreNLP

2016-08-10T22:49:00+00:00

En el post anterior analizamos los documentos extraidos del boletín oficial con una herramienta llamada Freeling. En este post vamos a repetir el mismo análisis pero usando CoreNLP.

CoreNLP es la suite de NLP desarrollada en Stanford. Por suerte para nosotros, cuenta con modelos en Español que si bien no son de lo más completos, nos van a permitir experimentar un poco.

Instalación

CoreNLP esta basado en Java (versión 8), es decir que vamos a necesitar tener Java instalado. Luego bajamos CoreNLP del sitio de descargas y bajamos los archivos de los modelos en Español de la misma página.

CoreNLP cuenta con una API RESTful, pero no es muy fácil de usar por lo que aquí vamos a usar un wrapper basado en NodeJS. Podemos encontrar el wrapper aquí. La API va a ser una simple app basada en ExpressJS. Los principales snippets (recortes) estan aquí:

//...
var NLPconfig = {
  nlpPath: nlpPath,
  version: '3.6.0',
  annotators: ['tokenize', 'lemma', 'ner', 'parse'],
  language: {
    jar: nlpPath + '/stanford-spanish-corenlp-2015-10-14-models.jar',
    properties: 'StanfordCoreNLP-spanish.properties',
  },
};
//..
var sendJSONresponse = function (res, status, content) {
  res.status(status);
  res.json(content);
};

var processAPI = function (req, res) {
  var txt = req.body.txt || '';
  console.log('Processing:', txt.slice(0, 10));
  app.coreNLP.process(txt, function (err, result) {
    sendJSONresponse(res, 200, result);
  });
};

router.post('/process', processAPI);
//...

Necesitamos la ubicación de CoreNLP y un archivo de configuración StanfordCoreNLP-spanish.properties cuyo contenido es:

annotators = tokenize, ssplit, pos, ner, regexner

tokenize.language = es

pos.model = edu/stanford/nlp/models/pos-tagger/spanish/spanish-distsim.tagger

ner.model = edu/stanford/nlp/models/ner/spanish.ancora.distsim.s512.crf.ser.gz
ner.applyNumericClassifiers = false
ner.useSUTime = false

parse.model = edu/stanford/nlp/models/lexparser/spanishPCFG.ser.gz

Nota: La información al respecto del docker container está en dockerhub.

Usar un único container puede ser muy limitante, por lo que decidimos lanzar 4 containers y un Nginx actuando como load balancer. El archivo de docker-compose usado es el siguiente:

version: '2'
services:
  app1:
    build: .
    image: malev/corenlp
    hostname: app1
    ports:
      - 3001:3001
    environment:
      PORT: 3001
    restart: always
# ... (Repite 3 veces)
loadbalancer:
    image: nginx
    ports:
        - 8080:80
    volumes:
        - ./corenlp.conf:/etc/nginx/conf.d/default.conf:ro

Analizando documentos

Desde el otro lado, vamos a usar un simple script python para enviar uno a uno los documentos del boletín oficial y vamos a almacenar los resultados en una base de datos Mongo.

import os
import sys
import json
import requests
from pymongo import MongoClient

client = MongoClient()
db = client.corenlp

filename = sys.argv[1]
corenlp_url = os.environ.get('CORENLP_URL', 'localhost:8080')

print("Working with {}".format(filename))


def get_tokens(data):
    tokens = []
    r = requests.post(
        "http://{}/api/process".format(corenlp_url),
        data={'txt': data['parsedText'].encode('utf-8')}
    )
    payload = json.loads(r.text)
    for sentence in payload['document']['sentences']['sentence']:
        for token in sentence['tokens']['token']:
            if type(token) == dict:
                token['idTramite'] = data['idTramite']
                token['sentenceId'] = sentence['$']['id']
                token['tokenId'] = token['$']['id']
                del token['$']
                tokens.append(token)
    return tokens


def already_in_db(id_tramite):
    return db.tokens.find_one({'idTramite': id_tramite})


def store_tokens(tokens):
    for token in tokens:
        db.tokens.insert_one(token)


with open(filename) as dfile:
    for element in dfile:
        try:
            data = json.loads(element)
            if not already_in_db(data['idTramite']):
                print("Working on {}".format(data['idTramite']))
                store_tokens(get_tokens(data))
        except Exception, e:
            print("Error in {}. {}".format(data['idTramite'], e.message))
            continue

print("Done!")

Para “acelerar los trámites”, podemos partir el archivo en partes y correr el script con cada una de ellas en un proceso nuevo:

split -n 20000 output.dat
python tokens.py output.0.dat
# En otra terminal:
python tokens.py output.1.dat

Y a esperar. La verdad que CoreNLP resultó ser muy lento. Al menos con la configuración que usamos aquí. Una vez que terminó de procesar todo podemos exportar los datos con:

mongoexport --db corenlp --collection tokens --out tokens.json

El problema de mongoexport es que va a incluir el _id que es específico de mongo e innecesario ara nosotros. Lo vamos a eliminar usando ramda-cli:

npm install -g ramda-cli
cat tokens.json | ramda-cli 'omit ["_id"]' -c > tokens_without_id.json

El código del proyecto se encuentra en Github y los resultados se pueden bajar de aquí . Seguiremos analizando el Boletín Oficial en futuros posts.

Fun Fact: El archivo exportado por mongodb pesa 7.1Gb. Luego de eliminar los ids de todos los documentos logramos reducir el tamaño del archivo a 5.1Gb. Victoria!

Analizando 40.000 documentos con NLP

2016-07-05T10:49:00+00:00

En un post anterior vimos como scrapear y extraer el texto de 40.000 documentos de la sección primera del boletín oficial argentino. En el de hoy, vamos a realizar un análisis de Natural Language Processing (NLP) en cada uno de esos documentos extraídos.

NLP

De todos las estudios que se pueden hacer con NLP vamos a hacer Named Entity Classification. Esto nos permitirá detectar verbos, sujetos, adjetivos, pronombres y signos de puntuación. Al mismo tiempo, y gracias a la herramienta que elegida, vamos a detectar personas, lugares geográficos, organizaciones y fechas. Todo esto lo vamos a hacer con una herramienta llamada freeling que se desarrolla en la Universitat Politècnica de Catalunya y cuenta con modelos para trabajar en el idioma Español. Destaco este punto porque la mayoría de las herramientas NLP trabajan casi exclusivamente en Inglés.

Empezamos instalando freeling con:

brew install freeling

o, en Ubuntu 14.04:

sudo apt-get update -yq
sudo apt-get install gdebi -yq
sudo apt-get install libboost-regex-dev libicu-dev zlib1g-dev \
                     libboost-system-dev libboost-program-options-dev \
                     libboost-thread-dev -yq

wget https://github.com/TALP-UPC/FreeLing/releases/download/4.0/freeling-4.0-trusty-amd64.deb
sudo gdebi -n freeling-4.0-trusty-amd64.deb

Para probarlo, necesitamos conocer la ubicación de los archivos de configuración:

En osx: /usr/local/Cellar/freeling/4.0/share/freeling/config
En Ubuntu: /usr/share/freeling/config/

Luego podemos ejecutar:

$ export FREELINGSHARE=/usr/local/Cellar/freeling/4.0/share/freeling/
$ echo "Hola mundo" | analyzer -f /usr/local/Cellar/freeling/4.0/share/freeling/config/es.cfg
Hola hola I 1
mundo mundo NCMS000 1

Y, como en este caso queremos el módulo nec de named entity classification, tendremos que correr:

$ echo "Abuelas encontró al nieto número 114" | analyze -f \
/usr/local/Cellar/freeling/4.0/share/freeling/config/es.cfg --nec --output json

Nuestro output será:

{
  "id": "1",
  "tokens": [
    {
      "id": "t1.1",
      "form": "Abuelas",
      "lemma": "abuelas",
      "tag": "NP00SP0",
      "ctag": "NP",
      "pos": "noun",
      "type": "proper",
      "neclass": "person",
      "nec": "PER"
    },
    {
      "id": "t1.2",
      "form": "encontr\u00f3",
      "lemma": "encontrar",
      "tag": "VMIS3S0",
      "ctag": "VMI",
      "pos": "verb",
      "type": "main",
      "mood": "indicative",
      "tense": "past",
      "person": "3",
      "num": "singular"
    },
    {
      "id": "t1.3",
      "form": "a",
      "lemma": "a",
      "tag": "SP",
      "ctag": "SP",
      "pos": "adposition",
      "type": "preposition"
    },
    {
      "id": "t1.4",
      "form": "el",
      "lemma": "el",
      "tag": "DA0MS0",
      "ctag": "DA",
      "pos": "determiner",
      "type": "article",
      "gen": "masculine",
      "num": "singular"
    },
    {
      "id": "t1.5",
      "form": "nieto",
      "lemma": "nieto",
      "tag": "NCMS000",
      "ctag": "NC",
      "pos": "noun",
      "type": "common",
      "gen": "masculine",
      "num": "singular"
    },
    {
      "id": "t1.6",
      "form": "n\u00famero",
      "lemma": "n\u00famero",
      "tag": "NCMS000",
      "ctag": "NC",
      "pos": "noun",
      "type": "common",
      "gen": "masculine",
      "num": "singular"
    },
    {
      "id": "t1.7",
      "form": "114",
      "lemma": "114",
      "tag": "Z",
      "ctag": "Z",
      "pos": "number"
    }
  ]
}

En este caso el resultado está en formato JSON y tiene un error ya que Abuelas es una organización y no una persona. Claramente el model necesita un poco de entrenamiento en DDHH argentinos. El entrenamiento será un cuento para otro día.

El código será escrito en python, y por ende necesitamos instalar un wrapper para freeling llamado pyfreeling. Su uso es muy similar al uso de analyze, la herramienta de línea de comandos que viene con freeling.

Map reduce

Este paso es opcional

El análisis nec consume mucha memoria, procesador y, por supuesto, mucho tiempo. Una forma simple de acelerar el proceso es usar más de un nodo o computadora. Aquí vamos a usar un map-reduce manual para dividir el proceso en 2 nodos: uno en DigitalOcean con 32Gb de ram y 12 CPUs y el otro, una laptop con 16Gb de ram y un procesador i7 de 3.1GHz.

El archivo con los 40.000 documentos pesa 325M y su estructura es la siguiente:

Un JSON por línea.
Cada JSON es un documento con título, metadata y contenido en HTML.

Cómo tenemos un JSON por línea, podemos dividir el archivo por número de líneas:

split -n 20000 output.dat

Dask nos permite paralelizar en multiples nodos, pero no vamos a usar ese feature en este post. El propósito es usar 2 nodos,

Ese comando nos va a dar 2 archivos con 20.000 documentos para usar en cada nodo.

Empezando con dask

Una vez copiado el archivo en cualquiera de los nodos, podemos leer su contenido con read_text y generar un objeto bag de Dask. También vamos a encadenar algunas funciones para parsear el JSON, extraer el texto del html, eliminar documentos nulos, etc:

import ujson
import dask.bag as db
from bs4 import BeautifulSoup


def extract(blob):
    return blob['dataList']


def remove_empty(data_list):
    return data_list


def valid_columns(data):
    return {
        'detalleNorma': data['detalleNorma'],
        'idTramite': data['idTramite']
    }


def extract_text(data):
    try:
        return {
            'idTramite': data['idTramite'],
            'parsedText': BeautifulSoup(data['detalleNorma'], "html.parser").\
                getText().strip()
        }
    except:
        return None

def remove_nones(data):
    return data is not None


bag = db.read_text("file_1.dat", blocksize=100000000)
df = bag.map(ujson.loads).map(extract).filter(remove_empty).\
    map(valid_columns).map(extract_text).filter(remove_nones)

Vamos a usar un blocksize de 100.000.000 que Dask organizará en 4 workers similares. Para generar esa gráfica usamos: from dask.dot import dot_graph; dot_graph(df.dask).

Análisis de entidades

Una vez que tenemos un bag de Dask con los datos y los workers listos podemos llamar a freeling con:

from pyfreeling import Analyzer

def tokenize(data):
    try:
        analyzer = Analyzer(config='/usr/share/freeling/config/es-ar.cfg')
        tokens = []
        xml_root = analyzer.run(data['parsedText'].encode('utf-8'), 'nec')
        for element in xml_root.iter():
            if element.tag == 'token':
                tokens.append(dict(element.attrib))
    except Exception as e:
        print(data['idTramite'])
        print(e)

    return {'idTramite': data['idTramite'], 'tokens': tokens}
tokens = df.map(tokenize)

Y luego bajamos todo a disco:

tokens.map(ujson.dumps).to_textfiles('{}.*.dat'.format(filename))

Esta tarea toma varias horas y como resultado obtendremos algunos archivos llamados: file1.dat.0.dat, file1.dat.1.dat, etc. Y su contenido será similiar a:

{
  "idTramite": "100000",
  "tokens": [
    {
      "ctag": "NP",
      "form": "MINISTERIO_DE_TRABAJO",
      "neclass": "organization",
      "pos": "noun",
      "nec": "ORG",
      "lemma": "ministerio_de_trabajo",
      "tag": "NP00O00",
      "type": "proper",
      "id": "t1.1"
    },
    {
      "ctag": "Fc",
      "form": ",",
      "pos": "punctuation",
      "lemma": ",",
      "tag": "Fc",
      "type": "comma",
      "id": "t1.2"
  },
  ...
  ]
}

Nota: La estructura con la que organizamos los tokens es muy ineficiente. No se es tabular y por lo tanto debe ser convertida en un último paso. Este último paso se podría haber omitido con una mejor estructura.

import ujson
from dask import bag

def tabulate(data):
    tokens = []
    for token in data['tokens']:
        token['idTramite'] = data['idTramite']
        tokens.append(token)
    return tokens

b = bag.read_text('file_1.dat.*.dat').map(ujson.loads).\
    map(tabulate).concat()
b.map(ujson.dumps).to_textfiles('tabulated.*.dat')

En próximos posts haremos análisis de los 33.276.028 datos obtenidos. Y si te queres adelantar, los podes bajar aquí.

Nota: Publiqué un notebook con el código de ejemplo usado aquí. Lamentablemente no se puede ejecutar pues Binder no tiene freeling instalado. Link al notebook.

Analizando el Boletín Oficial

2016-05-27T15:08:00+00:00

Analizando el Boletín Oficial

El Boletín Oficial, según Wikipedia, es “el medio de comunicación escrito que el Estado argentino utiliza para publicar sus normas jurídicas (tales como leyes, decretos y reglamentos) y otros actos de naturaleza pública, tanto del poder legislativo como del ejecutivo y el judicial”. Se compone de cuatro secciones que se enfocan en normas jurídicas, sociedades, contrataciones y dominios de internet respectivamente. Su sitio web es www.boletinoficial.gob.ar y por suerte es muy fácil de scrapear.

En este primer blogpost me voy a enfocar en la Primera Sección que incluye leyes, decretos, resoluciones y disposiciones emanadas de organismos públicos de los tres poderes del Estado.

Scraping the bad way

Si te interesa bajar la primera sección, hace click aquí.

Hace unos años atras escribí un post sobre consejos a la hora de hacer scraping. Hoy NO voy a respetar ninguno de esos consejos pues no tengo interes en reproducir este scraping ni nada por el estilo.

El primer paso consiste en visitar la página del Boletín Oficial y analizar qué tipos de llamadas se hacen desde el sitio.

Podemos distinguir, fácilmente, una llamada del tipo POST a secciones.json que devuelve un arreglo con los elementos de la Primera Sección para la fecha enviada como parámetro de la llamada.

Luego, hacemos click en caulquier decreto o resolución de la página. Una vez que la página se actualice veremos una llamada a detallePrimera, si la inspeccionamos veremos entre otras cosas el contenido del Decreto, la fecha de publicación, el nombre del archivo con el que fue publicado y su contenido. Esta va a ser la URL que vamos a probar con cURL:

$ curl --silent -q --data "numeroTramite=147002" \
https://www.boletinoficial.gob.ar/norma/detallePrimera

Y como resultado tendremos:

{
  "dataList": {
    "fechaEfectiva": "2016",
    "organismo": "CORTE SUPREMA DE\u00a0JUSTICIA DE\u00a0LA\u00a0NACI\u00d3N\r\n",
    "tipoNorma": "DECRETO",
    "numeroNorma": "Decreto 803",
    "anioNorma": "2016",
    "detalleNorma": "HTML CONTENT",
    "idTramite": "147002",
    "cantidadVisitas": 2135,
    "cantidadVisitasHoy": 2135,
    "fechaDeHoy": "20160623",
    "paginaDesde": "1",
    "paginaHasta": "1",
    "cantidadPaginasAfectadas": null,
    "cantidadPaginasAfectadasPor": null,
    "cantidadPaginasNormaFechaEfectiva": null,
    "cantidadPaginasVisitadas": null,
    "cantidadPaginasAnoexos": 0,
    "anexosNorma": [

    ],
    "normasAfectadas": [

    ],
    "normasAfectadasPor": [

    ],
    "fechasEfectivaNorma": [

    ],
    "normasVisitadas": [

    ],
    "idRubro": "24",
    "descRubro": "Decretos",
    "archivoPDF": "2016062301N.pdf",
    "fechaPublicacion": "20160623",
    "suplemento": false,
    "idTipoNorma": "2"
  },
  "id": "hcuvPSIvRwwrf5FU52+Ovi1bLS1JVi1bLUKbcb5YiYrnLAFxN7RJbCs=",
  "codigoError": 0,
  "mensajeError": ""
}

Eso es exactamente lo que queremos! Ahora vamos a usar seq y parallel para bajar los archivos con:

seq 100000 1 140000 | parallel -j10 \
"curl --silent -q --data "numeroTramite={}" \
https://www.boletinoficial.gob.ar/norma/detallePrimera --output {}.json"

Esto nos va a generar 40000 archivos JSON que voy a unir con:

for f in *.json; do (cat "${f}"; echo) >> output.dat; done

Así logramos un único (output.dat) archivo para empezar a jugar.

Cargar los datos

Para cargar los datos usamos Dask. Básicamente, leemos el archivo línea por línea, parseamos con ujson y si el resultado tiene un elemento llamada detalleNorma asumimos que es un documento válido. A cada documento le extraemos el exto con BeautifulSoup4. Pasamos todo el texto a minúsculas, filtramos los componentes que no son palabras, las denominadas stop words (palabras que no me dan valor) y por último contamos la aparición de cada palabra:

import re
import ujson
import dask.bag as db
from bs4 import BeautifulSoup


bag = db.read_text("output.dat")

is_word = lambda x: re.search("^[a-zA-ZáéíóúüñÁÉÍÓÚÜÑ]+$", x) is not None
not_is_stopword = lambda x: x not in nltk.corpus.stopwords.words('spanish')

def extract(blob):
    if blob['dataList']:
        html = blob['dataList'].get('detalleNorma', '')
        if html is not None:
            return BeautifulSoup(html, "html.parser").getText().lower().strip().split()
    return []

res = bag.map(ujson.loads).map(extract).concat().\
    filter(is_word).filter(not_is_stopword).\
    frequencies().compute()

Una vez que tenemos la frecuencia de cada palabra en todos los documentos de la Primera Sección ordeno y mostramos las 10 palabras más frecuentes:

sort = sorted(res, key=lambda x: x[1], reverse=True)
sort[0:10]

Top 10 de palabras en la sección primera

| Palabra   | Frecuencia |
|-----------|------------|
| dni       |     213703 |
| Nº        |      188174|
| nacional  |      184061|
| calibre   |      133918|
| ley       |      114651|
| decreto   |      112959|
| presente  |      112024|
| ministerio|      111594|
| fecha     |       96887|
| plg       |       75974|

Sólo a modo de prueba, hay publicado un notebook con algunos documentos y el código de este post aquí.

Nota: Tengo pensado jugar un poco más con estos datos en futuros posts.

City of Austin Employee Data Analysis

2016-05-19T21:22:00+00:00

The city of Austin has a very nice Open Data Portal. After digging a little bit I found that the most popular datasets in the portal are related to dogs, which it is not a surprise, since we are talking about the city of Austin. The truth is that there is a lot of data available. For this example, I’m going to be using the City of Austin Employee Detail Information for two reasons. One, it’s always interesting to see salaries and two, because I can try to reproduce the analysis that the people from the Texas Tribune are doing with the same data set.

Getting started

Obviously, I’m going to be using Python with Anaconda. You can find the installer and the instructions at the Continuum Analytics’s website. Once Anaconda has been installed, we are ready to go, since all the libraries are already part of the distribution.

We will start by importing pandas, numpy and matplotlib:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Then we will load the CSV file into pandas. Since the column Annual Salary has a data type of dtype('O'), we will need to convert into a float. As you can imagine, the problem is the $ sign:

df = pd.read_csv('City_of_Austin_Employee_Detail_Information.csv')
df[['Emp ID', 'Last', 'Annual Salary']][0:10]

| index  | Emp ID   | Last            | Annual Salary |
|--------|----------|-----------------|---------------|
| 0      | 10000003 | Turner          | $62608.00     |
| 1      | 10000008 | Michael         | $146101.28    |
| 2      | 10000015 | Greco           | $96345.60     |
| 3      | 10000022 | Wiswell-DeCampo | $45676.80     |
| 4      | 10000026 | White           | $109867.68    |
| 5      | 10000039 | Candoli         | $100800.96    |
| 6      | 10000066 | Mason           | $126349.60    |
| 7      | 10000084 | Lynch           | $94203.20     |
| 8      | 10000127 | Wosky           | $93977.52     |
| 9      | 10000132 | Ringuette       | $75487.36     |

We will create a new column called annual_salary with a parsed value from Annual Salary, so we can play with the data from this column.

df['annual_salary'] = df['Annual Salary'].map(lambda x: float(x.strip('$')))

Interesting findings

Most of the employees (28%) earns between 31k - 63k:

33% of males employees earn between 63k and 94k, against only 18% of female employees.

df[df['Gender'] == 'M'].groupby('salary_range')['Gender'].count()[2]/len(df[df['Gender'] == 'M'])
# => 0.33009231978000392
df[df['Gender'] == 'F'].groupby('salary_range')['Gender'].count()[2]/len(df[df['Gender'] == 'F'])
# => 0.18786289567334707

There is more people working in Parks & Recreation (2362) than in the police (2358).

Finally it’s pretty clear that most of the employees are white:

The rest of the analysis is nothing but pandas standard and you can check the jupyter notebook here. You can also play with it using Binder here (find it under the notebooks directory).

Experiencias de un Desarrollo Open Source

2014-10-16T15:38:00+00:00

En el año 2013 participé de PHPConf Argentina, donde hablé sobre las experiencias de trabajar en un proyecto Open Source. En este caso, sobre mi experiencia con analice.me y algunos debates conocidos de este mundillo.

Memoization

2014-10-08T10:45:00+00:00

Memoization in computer programs is a really simple concept. It’s an optimization technique where a computer program returns a cached result when the same input occurs again. It’s essential when working with heavy calculation algorithms or time consuming functions. It basically works like this:

Something calls a function
Function performs calculation
Function stores result in a cached variable
Funciton returns result
Someting calls the same function
Function returns cached value instead of performing heavy calculations
Win!

Ruby

In Ruby, memoization is almost part of the language thanks to Ruby’s conditional assignment (||=):

def slow_function
  sleep 5
  'result'
end

def memoization
  @takes_time ||= slow_function
end

memoization()
# Wait 5 seconds
=> 'result'
memoziation()
# Inmediateley
=> 'result'

We can also refactor a little bit using blocks (Ruby will treat this block as a single thing):

def slow_function
  @takes_time ||= begin
    sleep 5
    'result'
  end
end

slow_function()
# Wait 5 seconds
=> 'result'
slow_function()
# Inmediateley
=> 'result'

There is one caveat with this method. If slow_function returns nil, it will perform the heavy calculation every time. In that specific and annoying case we can use the object method defined?:

class HeavyClass
  def call
    return @call if defined?(@call)
    @call = slow_method
  end

  def slow_method
    sleep 5
    nil
  end
end

heavy_object = HeavyClass.new
heavy_object.call
# Wait 5 seconds
=> nil
heavy_object.call
# Inmediateley
=> nil

What if we use parameters? Simple, we will use a Hash. We will initialize our Hash with a block. According to the Ruby documentation if we call our hash with an unexisting key, it will call our block as:

hash = Hash.new do |h, key|
  h[key] = rand
end

hash[:non_existing_key]
=> 0.3884906318307012
hash[:other_non_existing_key]
=> 0.19581108461258834
hash[:non_existing_key]
=> 0.3884906318307012

Now, going back to our memoization post:

def takes_a_while
  sleep 5
  'result'
end

def slow_method(param)
  @hash ||= Hash.new do |h, key|
    h[key] = takes_a_while
  end
  @hash[param]
end

slow_method(1)
# Wait 5 seconds
=> 'result'
slow_method(1)
# Inmediately
=> 'result'
slow_method(2)
# Wait 5 seconds
=> 'result'

Python

Sadly, in Python things are not as easy as they are in Ruby, but that does not mean that they are impossible:

from time import sleep

cache = {}
def slow_method(param):
    if param in cache:
        return cache[param]
    else:
        sleep(5)
        cache[param] = param
        return cache[param]
slow_method(1)
# Wait 5 seconds
=> 1
slow_method(1)
# Inmediately
=> 1

We can also define a function and use it as a decorator as in:

from time import sleep

def memoize(f):
    memo = {}
    def helper(x):
        if x not in memo:
            memo[x] = f(x)
        return memo[x]
    return helper

@memoize
def slow_function(n):
    sleep(5)
    return n
slow_method(1)
# Wait 5 seconds
=> 1
slow_method(1)
# Inmediately
=> 1

If you are using Python 3 maybe you can check functools.lru_cache on the official documentation and if you are using Django you should also check the django-memoize library.

Javascript

We can define a method in the Function prototype and use a concept very similar as the Python one:

Function.prototype.memoize = function(){
  var self = this, cache = {};
  return function( arg ){
    if(arg in cache) {
      return cache[arg];
    } else {
      return cache[arg] = self( arg );
    }
  }
}

function slow() {
  console.log('Heavy calculation...');
  return 5;
}

var memSlow = slow.memoize();

> memSlow();
Heavy calculation...
5
> memSlow();
5

But if you are using underscore (and your should!) you can use the memoize method:

var fibonacci = _.memoize(function(n) {
  return n < 2 ? n: fibonacci(n - 1) + fibonacci(n - 2);
});

Much easier! We define the function once, and we don’t need to memoize it later.

What is all this doing here?

Well, if you work on data journalism you might be doing some scraping and some calculations on huge data sets. I think that the memoization concept is really useful to optimize some of your tools or scripts. Something to have in mind.