Capturar datos de una página web

Intentemos recuperar datos acerca de los miembros del parlamento del Uruguay. Para cada miembro de la Asamblea General, intentaremos recuperar su nombre, a qué partido pertenece, a qué comisiones pertenece, y datos acerca de su actividad parlamentaria. Que intentaremos recopilar aparecen en la página del plenario del Parlamento.

Empecemos por el final. Vayamos a la página de uno de los miembros y veamos cuáles son los proyectos que ha presentado:

library(httr)

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759/iniciativas-legislador"
r <- GET(URL)

Veamos en primer lugar el contenido al que nos enfrentamos:

res <- content(r, "text")

El problema es por tanto ver cómo podemos navegar y extraer elementos de HTML de la página. Para eso, httr no nos sirve y tenemos que recurrir a otro paquete. En este caso, usaremos rvest

library(rvest)
library(stringr)

Empecemos por leer el contenido de la página

spage <- read_html(URL)
spage

El paquete nos ofrece funciones para navegar y extraer elementos del modelo de la página. Por ejemplo, nos ofrece una función html_table que nos permite recuperar el contenido de las tablas o la función html_nodes para extraer nodos del DOM. Pero para ver qué tenemos que extraer, lo más práctico es empezar por examinar la página en developer mode.

Ahí vemos que lo que queremos extraer son los datos de la única tabla en la página:

datos <- spage %>%
    html_table() %>%
    .[[1]]
datos

Démosle a esta pequeña pieza de código un nombre para que sea más fácil de usar en el futuro:

extraer_proyectos <- function(url) {
    res <- read_html(url) %>%
        html_table() %>%
        .[[1]]
    return(res)
}

Vayamos ahora un nivel más arriba. De esta página nos interesan varias cosas. Por una parte, la tabla de la lista de las comisiones en las que esta persona participa. De nuevo, esto es una tabla y podemos usar código similar al anterior:

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759"
spage <- read_html(URL) %>%
    html_table() %>%
    .[[1]]

Y ponemos el código en otra función:

extraer_comisiones <- function(url) {
    res <- read_html(url) %>%
        html_table() %>%
        .[[1]]
    return(res)
}

También nos interesa obtener el partido al que pertenece. La información en este caso la podemos encontrar en un campo div al que podemos referirnos por su clase:

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759"
spage <- read_html(URL) %>%
    html_nodes("div.field-item")
spage

Vemos que obtenemos demasiados resultados. Podríamos referirnos al que nos interesa a través del orden que ocupa en el vector de retorno, pero parece más seguro referirnos por la información del contexto, como, por ejemplo, a qué grupo sigue.

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759"
spage <- read_html(URL) %>%
    html_nodes("div.field-name-field-persona-desc > div.field-items > div.field-item")
spage

De este resultado nos interesa únicamente el texto entre las etiquetas:

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759"
spage <- read_html(URL) %>%
    html_nodes("div.field-name-field-persona-desc > div.field-items > div.field-item") %>%
    html_text()
spage

Pongamos este código en otra función:

extraer_descripcion <- function(url) {
    res <- read_html(url) %>%
        html_nodes("div.field-name-field-persona-desc > div.field-items > div.field-item") %>%
        html_text()
    return(res)
}

Pero también nos interesa saber cómo acceder a los datos de los proyectos presentados, para recuperar la información que extrajimos antes. Para eso queremos saber cómo se llega desde esta página a la anterior. Lo que vemos es que esos resultados están disponibles en un enlace fijo (/iniciativas-legislador) que sigue al identificador único de esta persona. Podemos hacer dos cosas. Por una parte, sabiendo que la página está en una carpeta más profunda, podemos simplemente adjuntar ese nombre de carpeta a la URL con la que estamos trabajando. La otra alternativa es recuperar el enlace que aparece en la página y seguirlo. La segunda alternativa es más “segura.”

Para ello, podemos extraer todos los enlaces de la ficha y quedarnos con el que se llame Proyectos presentados

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759"
row <- read_html(URL) %>%
    html_nodes("div.pane-custom") %>%
    html_nodes("li") %>%
    html_text() %>%
    as.data.frame() %>%    
    mutate(matches=grepl("Proyectos presentados", .)) %>%
    summarize(row=which(matches)) %>%
    as.numeric
row

Ahora podemos seleccionar el elemento correspondiente en la tabla utilizando el código anterior

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759"
spage <- read_html(URL) %>%
    html_nodes("div.pane-custom") %>%
    html_nodes("li") %>%    
    .[[row]] %>%
    html_nodes("a") %>%    
    html_attr("href")
spage

Pongamos ahora este código en una función para que sea más fácil de operar.

extraer_link_proyectos <- function(url) {
    lists <- read_html(url) %>%
        html_nodes("div.pane-custom") %>%
        html_nodes("li")

    row <- lists %>%
        html_text() %>%
        as.data.frame() %>%    
        mutate(matches=grepl("Proyectos presentados", .)) %>%
        summarize(row=which(matches)) %>%
        as.numeric

    res <- lists %>%
        .[[row]] %>%
        html_nodes("a") %>%    
        html_attr("href")
    return(res)
}

La función para extraer los proyectos es similar a la anterior

extraer_proyectos <- function(url) {
    res <- read_html(url) %>%
        html_table() %>%
        .[[1]]
    return(res)
}

Pero ahora que tenemos esta función, podemos pensar en usarla más generalmente. Por ejemplo, uno de los enlaces de la tabla del perfil del miembro nos permite acceder a información sobre su asistencia a comisiones.

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759/asistencia-a-comisiones"
row <- read_html(URL) %>%
    html_table()
row

Digamos que nos interesa únicamente la información más desagregada. Por ejemplo, la segunda tabla. Extraer esta información es muy sencillo y podemos ponerlo en una función

extraer_asistencia <- function(url) {
    res <- read_html(url) %>%
        html_table() %>%
        .[[2]]
    return(res)
}

Pero, ahora que tenemos extraer_link_proyectos, podemos pensar en generalizer esta función para extraer no solo el link a los proyectos sino también el link a esta tabla:

extraer_link <- function(url, texto) {
    lists <- read_html(url) %>%
        html_nodes("div.pane-custom") %>%
        html_nodes("li")

    row <- lists %>%
        html_text() %>%
        as.data.frame() %>%    
        mutate(matches=grepl(texto, .)) %>%
        summarize(row=which(matches)) %>%
        as.numeric

    res <- lists %>%
        .[[row]] %>%
        html_nodes("a") %>%    
        html_attr("href")
    return(res)
}

Así, tenemos una función más general que podemos reusar para obtener otras piezas de información de la página

URL <- "https://parlamento.gub.uy/camarasycomisiones/legisladores/759"
extraer_link(URL, "Proyectos presentados")
extraer_link(URL, "Asistencia a Comisiones")

Ya solo nos queda una cosa por hacer. Ahora necesitamos ir a la primera página para obtener el listado de miembros del parlamento para poder recuperar toda la información anterior. Esta información la tenemos disponible en la sección Plenario de la página web. Aquí necesitamos dos cosas. Por una parte el nombre. Por otra, en enlace que nos permita seguir navegando. Las dos cosas las podemos encontrar en la tabla:

URL <- "https://parlamento.gub.uy/camarasycomisiones/asambleageneral/plenario/integracion"

spage <- read_html(URL) %>%
    html_nodes("span.field-content")
spage

Igual que antes, de aquí solo necesitamos un único tipo de contenido, al que podemos referirnos a través de la estructura del DOM

URL <- "https://parlamento.gub.uy/camarasycomisiones/asambleageneral/plenario/integracion"

link_ <- read_html(URL) %>%
    html_nodes("div.views-field-Psn-Codigo-1 > span > a") %>%
    html_attr("href")

text_ <- read_html(URL) %>%
    html_nodes("div.views-field-Psn-Codigo-1 > span > a") %>%
    html_text()

Ahora ya podemos poner todas las piezas juntas. El proceso es el siguiente. Para cada uno de los nombres que acabamos de extraer, seguiremos el enlace asociado, obtendremos la información relativa al miembro, capturaremos los enlaces que tengamos que seguir en ese punto y por último recuperaremos los proyectos y su asistencia a comisiones. Es decir, pondremos todas las piezas anteriores en un loop que empezará con la lista de miembros que acabamos de recuperar:

listado <- data.frame("nombre"=text_, "enlace"=link_)
listado

Las funciones ahora nos resultarán muy útiles para que código sea más legible. Para cada una de las entradas en listado, esto es lo que haremos:

capturar_datos_legislador <- function(url) {
    descripcion <- extraer_descripcion(url)
    comisiones <- extraer_comisiones(url)
    link_proyectos <- extraer_link(url, "Proyectos presentados")
    proyectos <- extraer_proyectos(link_proyectos)
    link_asistencia <- extraer_link(url, "Asistencia a Comisiones")
    asistencia <- extraer_asistencia(link_asistencia)
    return(list("descripcion"=descripcion,
                "comisiones"=comisiones
                "proyectos"=proyectos,
                "asistencia"=asistencia))
}

Lo único que tenemos que tener en cuenta es que las carpetas están definidas por su posición relativa. En concreto, parecen estar definidas por su posición relativa al TLD. Así pues:

BASEURL <- "https://parlamento.gub.uy"
full_url <- function(folder) {
    return(paste0(BASEURL, folder))
}

Nuestra función es ahora:

capturar_datos_legislador <- function(url) {
    url <- full_url(url)
    descripcion <- extraer_descripcion(url)
    comisiones <- extraer_comisiones(url)
    
    link_proyectos <- extraer_link(url, "Proyectos presentados")    
    link_proyectos <- full_url(link_proyectos)
    proyectos <- extraer_proyectos(link_proyectos)
    
    link_asistencia <- extraer_link(url, "Asistencia a Comisiones")
    link_asistencia <- full_url(link_asistencia)
    asistencia <- extraer_asistencia(link_asistencia)
    return(list("descripcion"=descripcion,
                "comisiones"=comisiones,
                "proyectos"=proyectos,
                "asistencia"=asistencia))
}

Y lo único que nos queda es aplicarla a cada una de las filas de la lista que recuperamos más arriba:

for (i in 1:nrow(listado)) {
    print(i)
    datos <- capturar_datos_legislador(listado[i, "enlace"])    
}

¿Por qué falla en la primera linea? Vayamos a la página correspondiente

listado[1, ]

En el código hemos asumido que cada una de las piezas que queremos extraer existen. En este caso, vemos que esta persona no pertenece a ninguna comisión. O, mejor dicho, ninguna comisión aparece listada. Lo que podemos hacer en este caso es “capturar una excepción” para que el código no falle:

tryCatch(extraer_comisiones(full_url(listado[1, "enlace"])),
         error=function(e) {return("No hay comisiones")})

Lo que vemos es que tryCatch intentará ejecutar extraer_comisiones. En el caso de que obtenga un error, entonces ejecutará en su lugar la función que hemos definido y que, por ahora, se limita a devolver información que puede ser útil.

capturar_datos_legislador <- function(url) {
    url <- full_url(url)
    descripcion <- extraer_descripcion(url)
    comisiones <- tryCatch(extraer_comisiones(url),
                          error=function(e) return("Ninguna comisión listada"))
    
    link_proyectos <- extraer_link(url, "Proyectos presentados")    
    link_proyectos <- full_url(link_proyectos)
    proyectos <- extraer_proyectos(link_proyectos)
    
    link_asistencia <- extraer_link(url, "Asistencia a Comisiones")
    link_asistencia <- full_url(link_asistencia)
    asistencia <- extraer_asistencia(link_asistencia)
    return(list("descripcion"=descripcion,
                "comisiones"=comisiones,
                "proyectos"=proyectos,
                "asistencia"=asistencia))
}

Por supuesto, podríamos (y deberíamos) asegurar que cada una de nuestras funciones tengan un tryCatch de tal modo que la ejecución no muera durante el proceso de captura. Pero, por ahora, nos sirve lo que tenemos.

Solo nos quedan un par de cosas. Por una parte, asociar a cada entrada el nombre del legislador. Para ello, lo almacenaremos todo en una lista de la que ya conocemos las dimesiones. Por último, entre llamada y llamada, dejaremos un tiempo de espera para no sobrecargar el servidor.

res <- vector('list', nrow(listado))
for (i in 1:nrow(listado)) {
    print(i)
    nombre <- listado[i, "nombre"]
    datos <- capturar_datos_legislador(listado[i, "enlace"])
    res[[i]] <- list("nombre"=nombre, "datos"=datos)
    Sys.sleep(5)
}