La API de twitter


Una fuente invaluable de lenguaje in the wild es Twitter, una red social de microbloging donde los usuarios escriben mensajes de hasta 140 letras (caracteres?), aunque pareciera que esta restricción fuera muy fuerte, Twitter ha crecido y se ha llegado a convertirse en una vía de comunicación preferida por un gran sector de la población. Un “tuit” luce así (aunque change is in the air ):

El texto de los tuits tiene asociado ciertos “metadatos”:

  • Menciones son etiquetas que hacen alusión a otros usuarios en la red, se marcan con el símbolo @ seguido del identificador del usuario.
  • Hashtags son etiquetas que marcan un tema o un sentimiento de nuestro tuit se marcan con el símbolo: # y una etiqueta (palabra)
  • Además en los tuits pueden aparecer links, ya sea a páginas o, a imágenes como es en el caso del ejemplo.

Dentro de la red social puede haber una “conversación” donde a un tuit se le responder (reply) como se muestra en el ejemplo anterior. Además los tuits se les puede citar.

API de twitter

Twitter pone a disposición una API que permite acceder a sus datos de forma responsable. Esta API se puede usar para crear aplicaciones de datos de twitter, en nuestro caso vamos a usar esta API para recolectar datos. Para experimentar con la API es necesario contar con una cuenta y registrar una aplicación. Pero antes de continuar pueden visitar la consola y construir algunas peticiones a la api y ver que tipo de resultados nos entrega.

La consola la pueden localizar aquí. Pueden usar el menú interactivo para construir un request, por ejemplo para obtener los tuits más recientes de un usuario se puede seleccionar la opción _usertimeline.json y llenando los argumentos solicitados, en particular el identificador y nombre de usuario, se llega a la siguiente dirección:

	https://api.twitter.com/1.1/statuses/user_timeline.json?count=2&user_id=ivanvladimir&screen_name=ivanvladimir

Esta request pide la versión 1.1 de la API, la función de revisar el estado, pide que se regresen dos tuits, del usuario @ivanvladimir. La interfaz de consola nos da información de los argumentos que son necesarios y cual es el objetivo de ellos. Al mandar la petición, la interfaz nos muestra el objeto regresado de la petición a la API, contenido ahí viene un objeto json con la información de los últimos dos tuits, como podrán notar viene toda, Toda, TODA la información asociada a ese tuit.

La documentación de la API se puede leer aquí

Restricciones de la API

La API pone restricciones de qué hacer con la información recuperada a través de ella y de cuanta información se puede acceder. Información precisa sobre como usar y las restricciones las pueden localizar en los siguientes links, es muy importante respetarlas y seguir sus recomendaciones.

Tokens de identificación

Para tener acceso a las funciones de la API y para llevar un control de acceso a nuestras aplicaciones Twitter requiere de tokens de acceso, estos son unos números que nos identifican durante la interacción con la API y definen los permisos que tenemos. Para cualquier aplicación y sobretodo para las peticiones que están restringidas es necesario contar con esto tokens. Estos se pueden solicitar en: https://apps.twitter.com/ registrando una app.

Existen dos tokens asociados a nuestra aplicación:

  • Consumer Key (API Key)
  • Consumer Secret (API Secret)

La segunda es sumamente importante que se mantenga secreta y no se haga disponible, de otra forma podrían abusar de ella y nuestra aplicación se vería afectada.

Además es necesario tener tokens de acceso, donde asociamos nuestra cuenta con la aplicación (es decir nos suscribimos a nuestra aplicación). Esos tokens también se pueden obtener en: https://apps.twitter.com/ en la sección de access tokens. Igualmente son dos tokens de nuestra identidad:

  • _Access Token
  • Access Token Secret

La API desde python

Existen varias opciones para acceder a Twitter desde python esto es deseable para crear procesos automáticos como: colectores de información, bots, analizadores, etc. Una opción muy estable es la librería tweepy (en github, documentación )

Instalaciónde tweepy

Para instalar la librería sólo falta hacer:

	pip install tweepy

Para versiones anteriores a las 2.7.9 de python muy probablemente habrá que seguir la siguientes instrucciones

Streaming

Una forma de acceder a los datos de twitter es conectarse al stream. En un stream se puede seguir la actividad de un tema en tiempo “real” sobre un subset muy pequeño de datos de twiter. El siguiente código con la librería Tweepy ejemplifica como conectarnos al stream público y seguir ciertos términos:

	from __future__ import division, print_function  # Python 2 users only
	import tweepy
	from tweepy import Stream
	from tweepy import OAuthHandler
	from tweepy.streaming import StreamListener
	import time
	import argparse
	import string
	import config
	import json
	import os

	verbose = lambda *a: None 
	keepcharacters = (' ','.','_')

	class Collector(StreamListener):

		def __init__(self, output_dir, query="#ironia", lang="es"):
			query_="".join(c for c in query if c.isalnum() or c in keepcharacters).rstrip()
			self.outfile=os.path.join(output_dir,lang+"_"+query_+".txt")
			verbose("Output file set to:", self.outfile)

		def on_data(self, data):
			try:
				with open(self.outfile, 'a') as f:
					f.write(data)
					verbose(data)
					return True
			except BaseException as e:
				print("Error on_data: %s" % str(e))
				time.sleep(5)
			return True

		def on_error(self, status):
			print(status)
			return True


	if __name__ == '__main__':
		# Command line options
		p = argparse.ArgumentParser("Twitter collector")
		p.add_argument("-q", "--query", dest="query",nargs="+",
						help="Query/Filter",default='#ironia')
		p.add_argument("-l", "--lang", dest="lang",
						help="Language",default='es')
		p.add_argument("-d","--data-dir",dest="data_dir",
					   help="Output/Data Directory", default='.')
		p.add_argument("-v", "--verbose",
				action="store_true", dest="verbose",
				help="Modo verbose [Off]")
		p.add_argument('--version', action='version', version='create_segments 0.1')
		opts = p.parse_args()

		# Prepara función de verbose  -----------------------------------------
		if opts.verbose:
			def verbose(*args,**kargs):
				print(*args,**kargs)
		else:   
			verbose = lambda *a: None 

		auth = OAuthHandler(config.consumer_key, config.consumer_secret)
		auth.set_access_token(config.access_token, config.access_secret)
		api = tweepy.API(auth)

		twitter_stream = Stream(auth, Collector(opts.data_dir, opts.query, opts.lang))
		twitter_stream.filter(track=[x.decode('unicode-escape') for x in opts.query],languages=[opts.lang])

Notar que hay que crear un archivo config.py con las variables adecuadas.Para ejecutarlo recomiendo:

	python twitter_collect.py -v -q "football"

Búsqueda

Búsqueda a diferencia de streaming no nos da los tuist en “tiempo real” sino los pasados. Otra diferencia, es que nos entrega páginas de estos resultados, por lo que tweepy ofrece el objeto Cursor para hacer transparente la interacción. El siguiente código ejemplifica como luce al final.

    with open(outfile, 'a') as f:                                                
        for tweet in tweepy.Cursor(api.search,                                   
                           q=[x.decode('unicode-escape') for x in opts.query],   
                           rpp=100,                                              
                           result_type="recent",                                 
                           languages=[opts.lang]).items(opts.nitems):            
                jtweet=json.dumps(tweet._json)                                   
                verbose(jtweet)                                                  
                f.write(jtweet) 

El código completo lo pueden localizar aquí. Para ejecutarlo recomiendo:

	python twitter_search.py -v -q "football"

Ligas de interés


comments powered by Disqus