Sergio Segura

Web Scraping for Data Analysis in Python (Parte V): Enriquecimiento de datos

Sat, 30 Nov 2019 00:00:00 +0000

En el artículo anterior conseguimos información espacial de cada uno de los items, algo que ya adelantamos que nos abriría muchas posibilidades en el futuro. En este artículo haremos uso de dicha información para cruzarla con otras fuentes de datos y así obtener información más relevante.

Existen diversas formas de realizar las operaciones espaciales que vamos a efectuar. El criterio que se ha seguido para elegir una herramienta u otra depende exclusivamente de la experiencia previa que se tenga con la misma. En este caso particular, he elegido utilizar la base de datos relacional con soporte para operaciones espaciales spatialite.

Configuración

Una de las grandes ventajas de spatialite es su portabilidad. Se trata de una herramienta auto-contenida que puede ser ejecutada desde cualquier directorio. El paquete se encuentra en los repositorios de Debian y Ubuntu por que puede ser instalada mediante sudo apt install spatialite-gui. Esto instalará la librería junto con su entorno gráfico.

Una vez instalado se puede iniciar ejecutando spatialite-gui en la terminal. Esto nos abrirá una ventana con la interfaz gráfica.

Carga de datos

Los datos que queremos cruzar en este caso de estudio provienen del Instituto Nacional de Estadística y expresan el salario medio por hogar con un grano de de detalle a nivel de sección administrativa (subdivisiones inferiores a un barrio). El problema es que dichos datos no contienen información espacial alguna, se trata de una simple tabla de tres columnas: sección , salario-por-hogar y salario-por-persona.

Para atajar esto usaremos una tercera fuente de datos, una capa espacial que contiene las geometrías de dichas secciones y nos permitirá determinar a qué sección pertenece cada item.

En nuestra base de datos tendremos, entonces:

Una capa de puntos con los items (pisos)
Una capa de geometrías con los distritos

Carga de los distritos

Para cargar la capa de geometrías, importaremos el dataset descargado. Al tratarse de un dataset en formato Shapefile, podemos importarlo directamente clickando en el icono Load Shapefile. Si estuviera en otro formato no compatible, sería necesario buscar la forma de convertirlo a Shapefile u a otro formato compatible.

En el proceso de importación se requerirá elegir el nombre de la tabla destino (en nuestro caso distritos) y el nombre de la columna espacial (la llamaremos geom) así como otros parámetros específicos como el SRID. El SRID indica el sistema de proyección usado y debería estar documentado en la fuente del dataset o en algún metadato adjunto. En el caso de los datos de distritos obtenidos, su SRID es 3042.

Si no fuera posible averiguar el SRID, se puede probar a utilizar software especializado como Quantum GIS, mucho más potente y versatil, pero con una complejidad que escapa a este artículo. Otra ventaja de incluir este software en el proceso será la capacidad de visualizar los resultados proyectados sobre un mapa.

Carga de los items

La carga de los item se hará con otra de las opciones compatibles que ofrece spatialite-gui, la carga desde CSV. Esto se logra clickando en Load CSV/TXT, eligiendo el fichero CSV correspondiente y completando los datos de formato del mismo, como el separador usado (habitualmente coma o tabulador), el nombre (en nuestro caso points) o el SRID. En este caso, no encontraremos documentación alguna sobre el SRID ya que estos datos nos hemos generado nosotros. No obstante, sabemos que los datos lat y lon provienen de coordenadas globales, a las cuales les corresponde el SRID 4326.

La tabla creada carecerá de una columna espacial por lo que deberemos crearla ejecutando las siguientes dos intrucciones desde la consola SQL:

SELECT AddGeometryColumn('points','geom',4326,'POINT',2);
UPDATE points SET geom = MakePoint(lon, lat, 4326);

Esto debería resultar en la creación de una columna nueva llamada geom con los correspondientes puntos en formato espacial. Podemos comprobar el proceso expandiendo la tabla points en la vista en árbol hasta ver el atributo geom, hacer click sobre él y seleccionar Map Preview. Esta previsualización debería mostrar los puntos correspondientes a cada item.

Consulta espacial

El siguiente paso es realizar lo que en tratamiento de datos de conoce como lookup. Básicamente, trataremos de añadir a cada item el distrito en el que se encuentra buscando la geometría en la que se encuentra contenido. Para ello utilizaremos la función de spatialite within() que nos dice si una geometría A se encuentra contenida en una geometría B.

select p.id, p.title, d.cusec
from points as p, distritos as d
where within(ST_Transform(p.geom, 3042), d.geom)==1
AND d.cpro=50;

De este modo, el resultado es una lista de tres columnas con el id, titulo y distrito de cada item. El código de distrito será el que podremos usar para cruzar con cualquier otro dato externo, como la renta media que antes mencionábamos.

Para cruzar las tres tablas: points, el resultado con los códigos de distrito y la fuente de datos externa, se puede usar la propia base de datos mediante SQL o se puede exportar el resultado a CSV haciendo click derecho sobre él y posteriormente agregar todo en una hoja de cálculo como Libre Office Calc o Excel.

Distancias

Una de las ventajas de tener los datos cargados en la base de datos espacial es que, con poco esfuerzo extra, podemos lograr extraer datos muy interesantes. Por ejemplo distancias mínimas (reales geográficas, no aproximaciones euclídeas) a puntos, trazados o polígonos. En nuestro caso de estudio, ya que se está recolectando una base de datos de pisos de alquiler de interés, puede resultar interesante conocer la distancia tu centro de trabajo, a la boca de metro más cercana o al tranvía que atraviesa tu cuidad.

Para ello, la consulta es muy similar a la anterior en estructura, pero variando la función utilizada. Además, ya no cruzaremos dos geometrías existentes, sino que proveeremos una de ellas.

select
	id,
	ST_Distance(
		ST_GeomFromText(
			'LINESTRING(-0.8708779781997009 41.68653240939767,-0.8898465603530212 41.687109287806656,-0.8900182217299744 41.679096624709025,-0.8901898831069275 41.6703135999149,-0.8838586602971645 41.66353877155025,-0.8843736444280239 41.661230381694274,-0.881026247577438 41.66090976544719,-0.8815841470525356 41.65776764174951,-0.8842878137395473 41.65404819516039,-0.8805541787908169 41.652124259193606,-0.8857898507878872 41.64728209938806,-0.8910513469900252 41.644907918854656,-0.898046548100865 41.63743525238525,-0.905284253258742 41.63226155866651,-0.9126274231276739 41.62269179353281,-0.9201805237136114 41.615986573308966,-0.9274257600052351 41.619661240493386)',
			4326
		),
		geom, 1
	) as dist_tranv,
	ST_Distance(
		ST_GeomFromText('POINT(-0.8892394427357431 41.68358071844347)', 4326),
		geom, 1
	) as dist_cps
from points;

Las geometrías o los puntos pueden generarse desde cualquier editor on-line de WKT (este es el formato de texto en el que definimos los puntos o las líneas).

Igual que en el caso anterior, el resultado puede ser agregado en la propia base de datos o en una hola de cálculo, la decisión depende de las preferencias y conocimientos de cada uno.

Web Scraping for Data Analysis in Python (Parte IV): Geoencoding

Fri, 22 Nov 2019 00:00:00 +0000

En el artículo anterior obtuvimos todos los datos estructurados que el portal web nos podía ofrecer. No obstante, podemos ir mucho (mucho) más allá aprovechando el resto de la web como fuente de datos. Una de las características más importantes que podemos desear conocer es la posición espacial que ocupa el item. Conocer las coordenadas exactas (o aproximadas) de un dato nos abre la puerta a un océano de datos espaciales con los que cruzar nuestros datos.

En nuestro caso de estudio, los pisos no cuentan con dicha información de forma fácilmente extraíble, pero si conocemos el nombre de la calle o la zona. Esto nos permite aplicar una técnica conocida como geoencoding: traducir de nombres a lugares.

Presentando: Nomatim (by OSM)

Nomatim es un servicio abierto de geoencoding basado en Open Street Maps. El servicio ofrece búsquedas ilimitadas y gratuitas siempre que se respeten unos acuerdos de uso, que restringen, entre otras cosas, la frecuencia de las peticiones.

Configuración

Los pre-requisitos en este caso serán:

python==3.6
requests==2.22.0

La librería requests, de hecho, no sería estrictamente necesaria, pero facilitará enormemente la realización de las peticiones al servidor.

Funcionamiento

La API de Nomatim

El servicio expone una API sencilla con la que podremos consultar por nombres de calles y plazas siguiendo un formato específico:

GET https://nominatim.openstreetmap.org/search?q=
	${Nombre+De+La+Calle}
	&polygon_geojson=1
	&viewbox=${latlon_left}%${latlon_top}%2C${latlon_right}%2${latlon_bot}
	&format=json

El resultado será un objeto JSON (ya que así ha sido solicitado en la API) con varios campos de interés como el display_name que permite supervisar que el resultado es el esperado, o los campos lat y lon que, como sus nombres indican, contienen las coordenadas del centroide de la geometría. Esto puede suponer un problema en el caso de calles largas, pero es la mejor aproximación que se puede realizar sin tener los números de los portales.

El código python para llamar a la API para nuestro caso de estudio:

url = 'https://nominatim.openstreetmap.org/search?q=' + \
	query.strip().replace(' ', '+')+'+Zaragoza+Aragon+Spain' + \
	'&polygon_geojson=1' + \
	'&viewbox=-1.30875%2C41.77592%2C-0.43327%2C41.51937' + \
	'&format=json'

headers = {
	'User-Agent': 'Python Script for Economics Study',
}

results = requests.get(url, headers=headers).json()

Algoritmo

El algoritmo a ejecutar no entraña misterio alguno:

Cargar el fichero CSV con todos los items
Iterar, para cada item 1.
1. Extraer su dirección
  1. “Limpiar” dicha dirección
  2. Realizar una búsqueda en nominatim
  3. Comprobar si, entre la lista de resultados, hay un resultado válido (dentro de un área razonable, por ejemplo)
  4. Si lo hay, continuar con el siguiente item
  5. Si no la hay, probar con otra “limpieza” y volver al principio de este bucle

Limpieza de datos

El filtrado de nombres es uno de los pasos más artesanales y más guiados por la prueba-error de todo el proceso. Se han detectado que los términos que más empeoran la búsqueda son ‘calle’, ‘plaza’, ‘avenida’ y ‘paseo’. La estrategia es detectar estos términos y eliminarlos del nombre.

También se han observado problemas con el artículo ‘de’, por lo que otro de los “niveles de limpieza” implica eliminar dichos artículos.

El código de limpieza de nombres se puede condensar en las siguientes dos funciones.

def rip(query):
	for pattern in ['calle', 'plaza', 'avenida', 'paseo']:
		if pattern in query:
			return _rip_pattern(pattern, query)
	return query

def _rip_pattern(pattern, query):
		if pattern+' de' not in query:
			return query.replace(pattern, pattern+' de')
		if pattern+' de' in query:
			return query.replace(pattern+' de', '')
		return query

Al final del proceso, se han logrado ubicar cerca del 80% de los pisos de nuestro caso práctico combinando las distintas técnicas de “limpieza”.

Web Scraping for Data Analysis in Python (Parte III): Scrapping

Fri, 15 Nov 2019 00:00:00 +0000

En el artículo anterior descargamos una copia local de todas las páginas que contenían información relevante para nosotros. Esto nos va a permitir trabajar con libertad a partir de este momento ya que no necesitaremos volver a acceder al portal. En otras palabras, podemos trabajar completamente offline.

Presentando: Scrapy

Mientras Selenium era una librería capaz de darnos el control absoluto de un navegador completo, Scrapy sigue una aproximación diferente: Analiza páginas HTML y ofrece un método muy sencillo para extraer información estructurada de ellas en formatos como CSV o JSON.

En muchos casos, Scrapy puede ser der usada directamente contra el servidor, pero en el caso de nuestro portal, se observó que el funcionamiento natural de la herramienta hacía que fuera muy fácil de detectar y las configuraciones necesarias para alterar ese funcionamiento eran complejas e inconsistentes.

Configuración

De modo similar a Selenium, los pre-requisitos son:

python==3.6
scrapy==1.7.3

En este caso, al no usar un navegador ni ningún otro servicio no será necesario descargar nada más. Por otro lado, sí que habrá que conocer la estructura de programa que Scrapy requiere, ya que éste es mucho más restrictivo que Selenium en ese aspecto.

Funcionamiento

La clase Spyder

La naturaleza de framework de Scrapy implica que hemos de adaptarnos a la estructura que propone, en este caso, extendiendo la clase Spider en un fichero python llamado, por ejemplo, scrapy.py:

Fragmento extraído de la documentación oficial

import scrapy


class MySpyfer(scrapy.Spider):
    name = "quotes"

    def start_requests(self):
        urls = [
            'http://quotes.toscrape.com/page/1/',
            'http://quotes.toscrape.com/page/2/',
        ]
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse)

    def parse(self, response):
        page = response.url.split("/")[-2]
        filename = 'quotes-%s.html' % page
        with open(filename, 'wb') as f:
            f.write(response.body)
        self.log('Saved file %s' % filename)

La función start_requests() debe devolver iterativamente objetos de tipo Request con la dirección deseada.
La función parse() será llamada por Scrapy recibiendo el objeto Response correspondiente a cada Request. De este objeto obtendremos toda la información deseada.

Creación de las URI

En nuestro caso, como las páginas estan descargadas localmente, las URI han de tener la estructura: file:///ruta/local_directorio/fichero.html

Otra opción es ejecutar un servidor local como http-server (de Node). scrapy crawl main -o ./data/main.csv

Scrapping de la página

Este apartado es fuertemente dependiente del sitio web a scrapear, ya que todas las directivas css y xpath son específicas para portal.

Tal y como se introdujo en con Selenium, el método de selección de elementos que usaremos será la sintaxis de CSS combinada con la sintaxis XPath (similar, pero más potente en algunos aspectos). El funcionamiento específico de ambas sintaxis es extenso y hay suficiente literatura escrita como para profundizar en ello todo lo que se desee.

En el caso que nos ocupa, los campos pueden ser extraidos de la siguiente manera:

def parse(self, response):
	flat = response.css('section.detail-info')

	title = flat.css('span.main-info__title-main::text').get()

	description = flat.css('.adCommentsLanguage').xpath('.//text()').getall()
	description = ' '.join(description)

Los dos casos básicos son, extracción de campos simples, como el título; y extración de listas, como la descripción, que luego es concatenada con espacios.

Devolución del resultado

Finalmente, con todos los campos extraídos en variables, queda sólo devolver el resultado en forma de diccionario python:

yield {
	'title': title,
	'description': description
}

Ejecución del experimento

Para lanzar el spider, será necesario ejecutar:

python -m scrapy runspider scrapy.py -o .data.csv

Esto iniciará el proceso de recolección de datos y debería generar un fichero CSV con una fila por cada item y una columna por cada campo devuelto en el diccionario python.

Web Scraping for Data Analysis in Python (Parte II): Protección contra crawlers

Fri, 08 Nov 2019 00:00:00 +0000

Tal y como se mencionó en la introducción, algunos sitios web establecen medidas de seguridad para evitar el acceso de crawlers. Tales medidas pueden abarcar desde una simple comprobación del User-Agent hasta un sofisticado sistema de registros y heurísticas que tratan de detectar a estos autómatas.

Nuestro trabajo será, precisamente, engañar a esos sistemas para evitar ser detectados y preparar una estrategia de recuperación en caso de bloqueo.

Presentando: Selenium

Cuando de trata de automatizar procesos sobre un navegador, Selenium sin duda la herramienta de referencia. Una de sus mayores ventajas es que, a diferencia de otras herramientas como Scrapy, que trabajan sobre documentos HTML descargados estáticamente, Selenium ejecuta y controla un navegador web al completo, por lo que es mucho más difícil de detectar.

Selenium esta disponible para multitud de lenguajes como Java, Javascript, Python, etc. Para este proyecto se ha decidido utilizar Python a lo largo de todo el proceso, tanto por la disponibilidad de las herramientas como por la popularidad del lenguaje entre sectores no-tic.

Configuración

Los pre-requisitos para seguir en proceso son:

python==3.6
selenium==3.141.0

En el directorio actual, crearemos el script con el nombre que deseemos, por ejemplo, crawl.py:

Comprobaremos que las dependencias son correctas escribiendo en el script:

from selenium import webdriver

print('Done')

De este modo, ejecutando python crawl.py deberíamos ver escrito por pantalla el mensaje Done.

Obtenicón del WebDriver

Selenium no trae instalado por defecto ningún navegador, por ello se ha de escoger uno y obtener su WebDriver por separado. El WebDriver es lo que le permitirá tomar el control del navegador, y ha de ser específico para cada navegador distinto. En este caso, optaremos por Firefox al ser el navegador de código libre más popular y robusto. El WebDirver se puede encontrar en su repositorio oficial.

Una vez descargado y descomprimido en el directorio local, podemos probar su funcionamiento editando el script.

from selenium import webdriver
import os
import time

BASE_PATH = os.path.abspath(os.path.dirname(__file__))
DRIVER_PATH = os.path.join(BASE_PATH,'geckodriver')
CACHE_PATH = os.path.join(BASE_PATH,'cache')

driver = webdriver.Firefox(executable_path=DRIVER_PATH)
driver.get(uri)
time.sleep(5)
driver.quit()

print('Done')

Directivas

Como ha mostrado el ejemplo anterior, Selenium permite controlar el navegador a través del objeto driver con directivas como driver.get() para navegar a una URI.

Las directivas que usaremos en este script son las cuatro siguientes:

get(): Accede a una URI
back(): Retrocede a la página anterior
find_elements_by_css_selector(): Selecciona un elemento de la página
quit(): Cierra el navegador

Guardado local de cada página

Recordamos que el objetivo de este script es guardar una copia local de cada página que encuentre para posteriormente ser analizada con otras herramientas.

Cuando el WebDriver carga una página, podemos acceder al contenido crudo de la misma mediante driver.page_source. De este modo, podemos guardar copias de las páginas HTML añadiendo:

with open(local_path, 'w') as local_page:
	local_page.write(driver.page_source)

Selección de elementos HTML

De entre las muchas formas que ofrece Selenium de seleccionar elementos, el selector CSS es una de las más sencillas de utilizar. Este método será también utilizado en posteriores etapas con otras herramientas.

Usando la sintaxis propia de CSS, podemos aplicar criterios de selección del mismo modo que lo haríamos en la hoja de estilos:

links = driver.find_elements_by_css_selector("a.icon-arrow-right-after")

La llamada anterior devuelve una lista con todos los elementos de tipo <a> (enlaces HTML) que además tengan la clase icon-arrow-right-after. El nombre de dicha clase ha sido obtenido manualmente utilizando el inspector de código de Firefox. Una vez se conoce el selector que se desea utilizar, su aplicación es automática por parte de Selenium.

Estructura de los elementos

Los elementos que devuelven las llamadas a find_*() son objetos internos de Selenium que contienen, entre otras cosas, los atributos del elemento HTML original. De este modo, el siguiente código permite obtener la URL a la que apuntaba dicho enlace:

link = links[0].get_attribute("href")

Navegación

Con dicho enlace, ya podemos llamar a la función get() para navegar a la siguiente página.

driver.get(link)

De un modo análogo se pueden obtener los enlaces a los pisos individuales y visitarlos uno a uno:

links = driver.find_elements_by_css_selector("a.item-link")
for link in links:
	driver.get(link)
	# Do something in the new page
	driver.back()

Check captcha

Una de las medidas que, sin duda, uno se puede encontrar cuando trabaja contra servicios protegidos contra bots son los captchas: retos sencillos de resolver por un humano pero difíciles para un autómata.

Para hacer frente a ellos, se ha optado por un enfoque semi-superviado en el que se observe el proceso ejecutarse de forma automática hasta que el portal web requiera la resolución de un captcha. En ese momento el script se detendrá a la espera de que el usuario supervisor resuelva el reto y éste pueda proseguir.

Para logar esto de forma cómoda y automática programaremos que, ante la detección de un captcha, el script entre en pausa un tiempo determinado y, tras ese tiempo, compruebe si el captcha ya ha desaparecido:

def check_captcha():
	captcha = driver.find_elements_by_css_selector("div.g-recaptcha")
		if len(captcha) > 0:
				while len(captcha) > 0:
						time.sleep(5)
						captcha = driver.find_elements_by_css_selector("div.g-recaptcha")

Deberemos llamar a esta función cada vez que pidamos una página nueva con get(). De este modo, cuando se vuelva de la función podremos estar seguros de que la página ya no contiene ningún captcha.

Algoritmo completo

El algoritmo completo entonces resultaría:

Visitar la primera página del listado de items
Guardar una copia de dicha página
Obtener los enlaces a cada item
Para cada item
1. Visitar el item
2. Guardar una copia de la página del item
3. Volver atrás
Obtener el enlace a la siguiente página del listado
Volver al primer punto

El código completo no ha sido compartido debido a que, en el proceso de desarrollo se implementó una estructura de guardado selectivo de páginas para facilitar las sucesivas ejecuciones del experimento que resulta totalmente innecesaria una vez de tiene controlado el proceso.

En el caso de contar con tiempo suficiente como para realizar una versión más concisa y legible, está será compartida junto con el resto del proyecto.

Web Scraping for Data Analysis in Python: a case study

Fri, 01 Nov 2019 00:00:00 +0000

En esta serie de artículos se cubrirá el proceso completo de Web Scraping y Enriquecimiento para el análisis de datos.

El factor de diferencial que busca este trabajo es profundizar un paso más allá de los habituales “tutoriales en condiciones perfectas”, así como dotarlo de un escenario realista gracias al caso de estudio.

Estructura de los artículos

El proyecto constará de una serie de 5 artículos:

El caso de estudio

Estamos a punto de mudarnos a una nueva cuidad y queremos toda la información posible para decidir qué piso alquilar. Para ello buscamos crear una base de datos con todos los pisos de alquiler disponibles en esa cuidad, y que ésta contenga más información que la que el buscador de la agencia de alquileres nos ofrece.

Esta información:

Puede estar presente en la web, pero no ser “consultable” en su sistema de búsqueda: el tipo de calefacción, certificación energética, el tipo de fianza, etc.
Puede estar implícita, pero no explícita: el precio por metro cuadrado, dividiendo dos campos explícitos; la localización espacial del piso, infiriéndola a partir de su dirección, etc.
Puede no estar disponible en la web, pero podemos obtenerla cruzando datos con la localización espacial: el tipo de zona en función del nivel de la renta o la edad media, la distancia a puntos de interés, etc.

Fuente de datos primaria

Se ha escogido el portal de datos de el Idealista como fuente principal de donde extraer los datos debido a dos motivos: gran cantidad de ofertas en la ciudad de estudio, Zaragoza; y fuertes medidas de seguridad contra crawlers y bots, que pretenden impedir la recolección de información de su portal (y hará este proyecto mucho más interesante).

Por motivos de precaución ante posibles infracciones de términos y condiciones de uso, ni el código completo ni los datos extraídos serán públicamente compartidos.