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 ):
Este es un ejemplo de 'tuit', tiene una mención @ivanvladimir, un hashtag #hashtag e incluye una imágen pic.twitter.com/pXn0OmrFBO
— ivanvladimir (@ivanvladimir) July 20, 2016
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.
Esta es una cita a un _tuit_ https://t.co/shzGC5FoGd
— ivanvladimir (@ivanvladimir) July 20, 2016
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 user_timeline.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.
- Límites 180 búsquedas por 15 minutos
- Directrices de desarrollos
- Contrato de uso
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 <em>stream</em> . 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"