2 Twitter desde Python y Colecta de Tweets.ipynb

{
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  },
  "name": "",
  "signature": "sha256:32e1825c30ee4228ac22540d238617f2539d6ce14e8882d6f1191ba3a2afe4cf"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Twitter desde Python y colecta de tweets"
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {
      "collapsed": true
     },
     "source": [
      "2.a Accediendo a Twitter y recolectando tweets"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__ *Esta secci\u00f3n requiere tener instalado el m\u00f3dulo __ `tweepy`__, contar con claves de una aplicaci\u00f3n de Twitter y de Mashape.__"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Acceder a Twitter desde Python tambi\u00e9n requiere que iniciemos sesi\u00f3n, esto lo haremos utilizando las claves que obtuvimos en el _notebook 0_. Podemos elegir entre las siguientes dos formas de iniciar de sesi\u00f3n: \n",
      "\n",
      "### **1ra Forma:** \n",
      "\n",
      "__Guardando nuestras claves en un archivo:__ Primero vamos a necesitar escribir nuestras claves con un formato que Python pueda interpretar, para esto completaremos los pasos siguientes:  \n",
      " * Abrir la carpeta de este taller. \n",
      " * Buscar el archivo `config.py`. \n",
      " * Abrir el archivo `config.py` utilizando un editor de texto.  \n",
      "\n",
      "Despu\u00e9s de abrir el archivo `config.py` debemos observar algo similar a esto:\n",
      "\n",
      "![](Imagenes/Sublime1.png)\n",
      "\n",
      "Finalmente:\n",
      "\n",
      " * Dentro del archivo `config.py` sutituiremos las palabras entre comillas por nuestra clave correspondiente.\n",
      " * Guardamos el archivo `config.py`.\n",
      "\n",
      "Para hacer consciente a Python del archivo anterior, ejecutamos lo siguiente desde el notebook de iPython: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import config"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Con el siguiente c\u00f3digo creamos las componentes necesarias para acceder a la API de Twitter."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import tweepy\n",
      "\n",
      "authentication = tweepy.OAuthHandler(config.consumer_key, config.consumer_secret)\n",
      "authentication.set_access_token(config.access_token, config.access_secret)\n",
      "\n",
      "api = tweepy.API(authentication)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Procedemos a explicar l\u00ednea por l\u00ednea el c\u00f3digo anterior.\n",
      " * La primer l\u00ednea importa el m\u00f3dulo `tweepy`, necesario para comunicar Python y Twitter.\n",
      " * La segunda l\u00ednea asigna el valor `tweepy.OAuthHandler(config.consumer_key, config.consumer_secret)` a la variable `authetication`. Observe que el valor anterior tiene dos argumentos `config.consumer_key` y  `config.consumer_secret` los cuales se refieren al _consumer key_ y _consumer secret_ que utilizamos para actualizar el archivo `config.py`,\n",
      " * La tercera l\u00ednea establece el _token_ de acceso del objeto de autenticaci\u00f3n, que es el resto de las _tokens and keys_ que utilizamos para actualizar el archivo `config.py`,  \n",
      " * La cuarta l\u00ednea inicializa una variable llamada `api` asign\u00e1ndole nuestras claves de autorizaci\u00f3n guardadas en `authentication`. Es trav\u00e9s de `api` c\u00f3mo iniciaremos sesi\u00f3n en Twitter desde Python y podremos hacer uso de los datos.\n",
      "\n",
      "### **2da Forma:**\n",
      "En cada c\u00f3digo que vayamos a utilizar podemos utilizar variables para guardar los _keys / tokens_, como en el siguiente ejemplo:   "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import tweepy\n",
      "\n",
      "consumer_key='XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "consumer_secret= 'XXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_token = 'XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "\n",
      "authentication= tweepy.OAuthHandler(consumer_key, consumer_secret)\n",
      "authentication.set_access_token(access_token, access_secret)\n",
      "\n",
      "api = tweepy.API(authentication)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Nota**: La ventaja de la primera forma sobre la segunda, es que puedes compartir el c\u00f3digo y mantienes en secreto tus claves de acceso, mientras en la segunda siempre hay que tener el cuidado de borrar las claves de acceso antes de compartir el c\u00f3digo.\n",
      "\n",
      "Por el momento no es necesario entender m\u00e1s del c\u00f3digo anterior, pues ya tenemos una impresi\u00f3n general de lo que esta sucediendo en \u00e9l mismo, y b\u00e1sicamente esto es un _log-in_ que debemos hacer para accerder a la API de Twitter.\n",
      "\n",
      "Ahora que ya estamos dentro de la API de Twitter, podemos utilizar la variable `api` para realizar muchas de las acciones comunes en Twitter, como acceder al historial de tweets (_time line_) de la p\u00e1gina principal de nuestra cuenta:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for tuit in tweepy.Cursor(api.home_timeline).items(10):\n",
      "    print(tuit.text)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Cada que solicitemos informaci\u00f3n usando la variable <span style=\"color:red\">_api._ </span> estamos realizando una llamada a trav\u00e9s de la API. El c\u00f3digo anterior utiliza una llamada y toma los 10 tweets m\u00e1s recientes de nuestro timeline (`api.home_timeline`), a trav\u00e9s de un ciclo `for` imprime el texto de cada uno mediante la instrucci\u00f3n  `print(tweet.text)`. \n",
      "\n",
      "Algunas acciones como realizar demasiadas llamadas en poco tiempo, cometer errores al escribir las claves de acceso, etc devuelvan un error acompa\u00f1ado de un c\u00f3digo que identifica el problema. Cuando esto ocurre debemos comparar el c\u00f3digo del error que obtenemos con la [documentaci\u00f3n oficial](https://developer.twitter.com/en/docs/basics/response-codes) para corregir el problema.\n",
      "\n",
      "**Nota:** La API de Twitter restringe a 15 el n\u00famero de llamadas durante intervalos de 15 minutos. En caso contario nuestra cuenta queda temporalmente bloqueada hasta satisfacer un tiempo de espera de 15 minutos."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n",
      "**Ejercicio** Actualizar el n\u00famero 10 por cualquier otro n\u00famero y volver a ejecutar el c\u00f3digo."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Con la misma variable `api` tambi\u00e9n podemos acceder al ``screen_name`` de todos los usuarios a quienes sigues, escribiendo el siguiente c\u00f3digo: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for follower in tweepy.Cursor(api.friends).items():\n",
      "    print(follower.screen_name)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Tambi\u00e9n, podemos acceder al texto de nuestros 10 \u00faltimos tweets, escribiendo lo siguiente: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for tuit in tweepy.Cursor(api.user_timeline).items(10):\n",
      "      print(tuit.text)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "En los dos \u00faltimos c\u00f3digos utilizamos un ciclo `for`, el cual se ejecuta en `api.friends` y `api.user_timeline` respectivamente e imprime una lista con todos nuestros seguidores `print(follower)` y una lista con nuestros \u00faltimos 10 tweets `print(tweet.text)` respectivamente. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Nosotros conocemos _a priori_ la informaci\u00f3n de nuestra cuenta, sin embargo tambi\u00e9n podemos obtener informaci\u00f3n similar de otras cuentas bajo ciertas limitantes. \n",
      "\n",
      "Un usuario de Twitter puede ser representado en Python mediante un _objeto_, es decir, mediante un conjunto variables empaquetadas. Como usuarios de Twitter recordemos que al crear una cuenta debemos ingresar cierta informaci\u00f3n (nombre de usuario, n\u00famero telef\u00f3nico, localizaci\u00f3n, lenguaje, preferencias, correo electr\u00f3nico, etc), y parte de esta informaci\u00f3n tambi\u00e9n ser\u00e1 visible a otros usuarios (incluso desde la API). Todos estos datos, en su conjunto, representan a un usuario; veamos qu\u00e9 significa esto ejecutando el siguiente c\u00f3digo (accediendo a la API de la segunda forma):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import tweepy\n",
      "\n",
      "consumer_key='XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "consumer_secret= 'XXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_token = 'XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "\n",
      "authentication= tweepy.OAuthHandler(consumer_key, consumer_secret)\n",
      "authentication.set_access_token(access_token, access_secret)\n",
      "\n",
      "api = tweepy.API(authentication)\n",
      "\n",
      "usuario= api.get_user(screen_name=\"TuUsuario\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Las primeras cinco l\u00edneas las hemos explicado antes y s\u00f3lo sirven para iniciar sesi\u00f3n en caso de que no lo hayamos hecho antes. En la \u00faltima l\u00ednea debemos reconocer que ``usuario=`` es una expresi\u00f3n que sirve para almacenar _algo_ en la variable ``usuario``. En este caso estamos almacenando la inforamci\u00f3n de una cuenta, la cual se compone de muchos tipos de variables ya que el `screen_name` (nombre de usuario) es una cadena de texto, `followers_count` (n\u00famero de seguidores) y `friends_count` (n\u00famero de amigos) son variables num\u00e9ricas, etc.\n",
      "\n",
      "Para conocer todas las variables _empaquetadas_ que se asocian con una cuenta podemos escribir el nombre de la variable principal (`usuario`), seguido de un punto, y presionamos la tecla _TAB_ $\\left[\\overset{\\leftarrow}{\\rightarrow}\\right]$. Esto desplegar\u00e1 un men\u00fa como se muestra en la siguiente imagen.\n",
      "\n",
      "![Desplegar todos los campos](./Imagenes/menu.png)\n",
      "\n",
      "Puedes intentarlo en la siguiente l\u00ednea:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "usuario."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Este men\u00fa contiene las siguientes variables: `contributors_enabled, created_at, default_profile, default_profile_image, description, entities, favourites_count, follow, follow_request_sent, followers, followers_count, followers_ids, following, friends, friends_count, geo_enabled, has_extended_profile, id, id_str, is_translation_enabled, is_translator, lang, listed_count, lists, lists_memberships, lists_subscriptions, location, name, notifications, parse, parse_list, profile_background_color, profile_background_image_url, profile_background_image_url_https, profile_background_tile, profile_banner_url, profile_image_url, profile_image_url_https, profile_link_color, profile_location, profile_sidebar_border_color, profile_sidebar_fill_color, profile_text_color, profile_use_background_image, protected, screen_name, status, statuses_count, time_zone, timeline, translator_type, unfollow, url, utc_offset, verified`.\n",
      "\n",
      "De esta manera, si escribimos por ejemplo:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(usuario.created_at)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "se imprimir\u00e1 la fecha de creaci\u00f3n de la cuenta.\n",
      "\n",
      "\n",
      "**Ejercicio**. Crea una lista que contenga el `screen_name` de cinco cuentas y completa el siguiente c\u00f3digo para imprimir el nombre de usuario seguido del n\u00famero de seguidores de cada elemento en la lista."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "L=['cuenta1', 'cuenta2', 'cuenta3', 'cuenta4', 'cuenta5' ] # Aqui debes reemplazar cuentaX por el screen_name de cada cuenta\n",
      "\n",
      "for nombre in L:\n",
      "    usuario= api.get_user(nombre)\n",
      "    print(usuario.screen_name, usuario.followers_count)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Inspeccionando las variables que componen al objeto `usuario`, encontramos **id** y **followers_ids**. La primera es una variable num\u00e9rica que identifica a cada usuario de Twitter con un n\u00famero, de manera que aunque un  usuario cambie el nombre de su `screen_name`, su `id` siempre permanece igual. Por otra parte la variable `followers_id` nos devuelve una lista de Python con los `ids` de los usuarios que siguen a `usuario`. Veamos:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Para el id de usuario\n",
      "print(usuario.id)\n",
      "#Para la lista con sus seguidores\n",
      "#  ****** NOTEMOS EL PAR DE PARENTESIS AL FINAL !!!!!!\n",
      "print(usuario.followers_ids())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Es posible que la API no devuelva la lista completa de seguidores/seguidos, si estos son demasiados. Para obtener todo el listado la mejor opci\u00f3n opci\u00f3n es hacer una llamada para determinar el n\u00famero total de seguidores/seguidos, posteriormente haremos varias llamadas para obtener listados parciales con un m\u00e1ximo de 5000 seguidores/seguidos cada uno, es decir, el listado total lo obtendremos colectando subconjuntos de 5000 (para cada subconjunto necesitamos hacer una llamada desde la API). Cada uno de estos listados parciales se especifica mediante un \u00edndice llamado __cursor__, el cual siempre asigna el \u00edndice 0 cuando hayamos obtenido la lista completa y le asigna el -1 al primer listado. Verifiquemos estas ideas en el siguiente c\u00f3digo:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import tweepy\n",
      "\n",
      "consumer_key='XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "consumer_secret= 'XXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_token = 'XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "\n",
      "authentication= tweepy.OAuthHandler(consumer_key, consumer_secret)\n",
      "authentication.set_access_token(access_token, access_secret)\n",
      "\n",
      "api = tweepy.API(authentication)\n",
      "\n",
      "cuenta= \" \" #Escribe aqui una cuenta con mas de 5000 seguidores (preferentemente)\"\n",
      "\n",
      "# Determinemos el numero exacto de seguidores (limite)\n",
      "usuario= api.get_user(screen_name=cuenta)\n",
      "limite=usuario.followers_count\n",
      "\n",
      "idx=-1 \n",
      "\n",
      "seguidores=[] #Aqui guardaremos todos los listados\n",
      "\n",
      "# Obtengamos los listados parciales hasta llegar al ultimo (con indice 0)\n",
      "while idx!=0:\n",
      "    S=api.followers_ids(cuenta,count=5000,cursor=idx)\n",
      "    for elemento in S[0]:\n",
      "        seguidores.append(elemento)\n",
      "    idx=S[1][1]\n",
      "\n",
      "print(limite)\n",
      "print(len(seguidores))\n",
      "print(seguidores[:10]) # Probamos imprimiendo los 10 primeros de la lista"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__Ejercicio.__ Sustituye `followers_ids` por `friends_ids` y `seguidores` por `friends` para obtener el listado de las cuentas seguidas por la cuenta especificada.\n",
      "\n",
      "__Nota:__ Si la cuenta tiene demasiados seguidores/seguidos debemos cuidar de no agotar el l\u00edmite de 15 llamadas cada 15 minutos, de ser as\u00ed s\u00f3lo debemos esperar y continuar desde el \u00faltimo \u00edndice.\n",
      "\n",
      "Ahora utilizaremos nuestra aplicaci\u00f3n para **recolectar los \u00faltimos tweets** acerca de un tema en particular, evento o persona. Para esto necesitamos utilizar una nueva funci\u00f3n de _tweepy_, que es el `StreamListener`, el cual utilizamos en el siguiente c\u00f3digo para imprimir todos los nuevos tweets que contienen la palabra _Python_. Hemos dividido el siguiente c\u00f3digo en cuatro bloques, lo cuales explicaremos m\u00e1s adelante, por ahora s\u00f3lo haremos \u00e9nfasis en la instrucci\u00f3n <span style=\"color:red\"> if dt.total$\\_$seconds()$< $15 </span> Esta instrucci\u00f3n se encuentra dentro del _Bloque 3_ y se encarga de verificar el tiempo transcurrido para detener el proceso de recolecci\u00f3n despu\u00e9s de 15 segundos. Podemos reemplazar el n\u00famero 15 por el tiempo  __en segundos__ que queremos que dure la recolecci\u00f3n de tweets."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Bloque 1\n",
      "import tweepy\n",
      "from tweepy import Stream\n",
      "from tweepy.streaming import StreamListener\n",
      "import datetime\n",
      "\n",
      "\n",
      "# Bloque 2\n",
      "consumer_key='XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "consumer_secret= 'XXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_token = 'XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "\n",
      "authentication= tweepy.OAuthHandler(consumer_key, consumer_secret)\n",
      "authentication.set_access_token(access_token, access_secret)\n",
      "\n",
      "# Bloque 3\n",
      "class TwitterListener(StreamListener):\n",
      "    StreamListener.inicio=datetime.datetime.now()\n",
      "    \n",
      "    def on_status(self, status):\n",
      "        dt=datetime.datetime.now()-StreamListener.inicio\n",
      "        if dt.total_seconds()<15: # Sustituimos \"15\" por el tiempo en segundos durante el que se colectaran tweets\n",
      "            try:\n",
      "                print(status.text)\n",
      "            except:\n",
      "                pass\n",
      "        else:\n",
      "            twitter_stream.disconnect()\n",
      "            return\n",
      "\n",
      "# Bloque 4\n",
      "\n",
      "twitter_stream = Stream(authentication, TwitterListener())\n",
      "twitter_stream.filter(track=['python'])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ahora procedemos explicar el c\u00f3digo anterior por bloques.\n",
      " * En el primer bloque importamos los m\u00f3dulos necesarios. \n",
      " * En el segundo bloque iniciamos sesi\u00f3n desde la API.  \n",
      " * En el tercer bloque especificamos las instrucciones para descargar tweets, en este ejemplo llevamos un conteo del tiempo e imprimeros el texto de los tweets.\n",
      " * En el cuarto bloque iniciamos la descarga usando (`stream`) para filtrar aquellos tweets que contegan la palabra _python_ (\u00faltima l\u00ednea). "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Ejercicio**. Actualizar la palabra Python por cualquier otra palabra y volver a ejecutar el c\u00f3digo."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Ejercicio**. Trate de buscar otro t\u00e9rmino o t\u00e9rminos."
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "2.c Preprocesamiendo de Datos"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Comenzamos la segunda parte de este curso, en ella vamos a realizar algunos pasos de preprocesamiento del texto que necesitamos para su an\u00e1lisis.\n",
      "\n",
      "Recordemos que tenemos un c\u00f3digo que _recolecta tweets_. Ahora guardaremos nuestros tweets en la carpeta `data/` con el nombre `stream_[XX].json`, donde `XX` debe ser sustituida por la consulta realizada. \n",
      "\n",
      "Antes de continuar debemos saber que un tweet, al igual que un usuario, tambi\u00e9n puede representarse mediante un _objeto_, es decir, un conjunto de variables de diferentes tipos. Las variables que representan a un tweet son distintas de aquellas que representan a los usuarios. Comencemos obteniendo un tweet de nuestro _timeline_."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import tweepy\n",
      "\n",
      "consumer_key='XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "consumer_secret= 'XXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_token = 'XXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "\n",
      "authentication= tweepy.OAuthHandler(consumer_key, consumer_secret)\n",
      "authentication.set_access_token(access_token, access_secret)\n",
      "\n",
      "api = tweepy.API(authentication)\n",
      "\n",
      "for tuit in tweepy.Cursor(api.home_timeline).items(1):\n",
      "    ejemplo_de_tuit=tuit"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ahora despleguemos los campos que contienen la informaci\u00f3n de un tweet de la misma manera que lo hicimos para los usuarios: Escribimos el nombre de la variable principal (`ejemplo_de_tuit`), seguido de un punto, y presionamos la tecla _TAB_ $\\left[\\overset{\\leftarrow}{\\rightarrow}\\right]$ para desplegar el men\u00fa de las variables que componen al tweet, como son la fecha de creaci\u00f3n del tweet, el usuario que lo cre\u00f3, si fue un retweet (y de qui\u00e9n fue el tweet original), etc."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(ejemplo_de_tuit)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Por ejemplo, el siguiente c\u00f3digo imprime el nombre del usuario que realiz\u00f3 el tweet almacenado en `ejemplo_de_tuit`, la hora y el texto que contiene."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(ejemplo_de_tuit.user.screen_name,ejemplo_de_tuit.created_at,ejemplo_de_tuit.text)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Observemos que un tweet contiene bastante informaci\u00f3n, como por ejemplo, el usuario que lo escribe, la fecha en que fue escrito, la geolocalizaci\u00f3n, etc. Para nuestros prop\u00f3sitos los campos m\u00e1s importantes son:\n",
      " * text: el texto real del tweet,\n",
      " * created_at: la fecha de creaci\u00f3n,\n",
      " * favorite_count: el n\u00famero de los favoritos de este tweet,\n",
      " * retweet_count: el numero de retweets,\n",
      " * lang: el lenguaje del tweet,\n",
      " * id: el identificador del tweet,\n",
      " * place: informaci\u00f3n de geolocalizaci\u00f3n,\n",
      " * user: el perfil del autor del tweet.\n",
      " \n",
      "As\u00ed como podemos guardar documentos en diferentes tipos de archivos y formatos, guardaremos tweets en formato de _json_, el cual es una manera com\u00fan de almacenar datos en internet, en el siguiente c\u00f3digo podemos ver esta acci\u00f3n."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "#Codigo para escribir archivos json\n",
      "import json\n",
      "\n",
      "with open(\"./data/stream_lunch.json\",\"a\") as archivo:\n",
      "    archivo.write(json.dumps(ejemplo_de_tuit._json, sort_keys=True))\n",
      "    archivo.write('\\n')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "L\u00ednea por l\u00ednea, el c\u00f3digo anterior hace lo siguiente:\n",
      "\n",
      " * Importa el m\u00f3dulo ``json`` (necesario para escribir/leer archivos en este formato).\n",
      " * En la carpeta ``data`` crea un archivo llamado ``stream_lunch.json``, el cual ser\u00e1 llamado por Python mediante la variable ``archivo`` .\n",
      " * Despu\u00e9s, se escribe el tweet `ejemplo_de_tuit` como contenido del archivo creado.\n",
      " * Por \u00faltimo, damos un salto de l\u00ednea al termino del tweet. Aunque este paso es opcional, es recomendable hacerlo para que el archivo contenga un tweet por l\u00ednea.\n",
      " \n",
      "De forma an\u00e1loga, podemos leer del archivo el tweet que acebamos de guardar."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Codigo para leer archivos json\n",
      "import json\n",
      "\n",
      "with open(\"./data/stream_lunch.json\",\"r\") as archivo:\n",
      "    renglones=archivo.readlines()\n",
      "    for data in renglones:\n",
      "        tuit=json.loads(data)\n",
      "        print(tuit['created_at'])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Nota:** Comparando los c\u00f3digos de escritura y lectura de archivos _json_, notamos que la l\u00ednea encargada de abrir/crear un archvio es id\u00e9ntica en ambos casos, excepto por el par\u00e1metro \"a\" \u00f3 \"r\". En el primer caso, el par\u00e1metro \"a\" significa _append_ (o agregar), es decir, cada vez que realicemos un ``archivo.write`` agregaremos una l\u00ednea al archivo, conservando todo el contenido previo. Mientras que el par\u00e1metro \"r\" significa _read_ (o leer) y no podremos realizar ning\u00fan proceso de escritura en el archivo, simplemente leerlo. An\u00e1logamente, para sobrescribir el archivo escribimos una \"w\".\n",
      "\n",
      "**Nota:** En el c\u00f3digo de lectura de archivos _json_, la instrucci\u00f3n ``json.loads(data)`` traduce en un objeto de Python la l\u00ednea que leimos del archivo, pero en este caso accedemos a los campos o variables que conforman a tweet mediante par\u00e9ntesis cuadrados [ ] y escribiendo entre comillas el nombre del campo; y no mediante el nombre de la variable principal y un punto, como cuando obtenemos el tweet directamente de la API.\n",
      "\n",
      "Comparar:\n",
      "\n",
      "``tuit['created_at']``\n",
      "\n",
      "con \n",
      "\n",
      "``tuit.created_at``.\n",
      "\n",
      "Ahora guardemos en un archivo el flujo de tweets de una palabra en espec\u00edfico:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from tweepy import Stream\n",
      "from tweepy.streaming import StreamListener\n",
      "\n",
      "import json\n",
      "import tweepy\n",
      "import datetime\n",
      "\n",
      "consumer_key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "consumer_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_token = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "access_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'\n",
      "\n",
      "\n",
      "authentication = tweepy.OAuthHandler(consumer_key, consumer_secret)\n",
      "authentication.set_access_token(access_token, access_secret)\n",
      "\n",
      "class TwitterListener(StreamListener):\n",
      "    StreamListener.inicio=datetime.datetime.now()\n",
      "    \n",
      "    def on_data(self, data):\n",
      "        dt=datetime.datetime.now()-StreamListener.inicio\n",
      "        if dt.total_seconds()<15: # Sustituimos \"15\" por el tiempo en segundos durante el que se colectaran tweets\n",
      "            try:\n",
      "                tweet=json.loads(str(data))\n",
      "                print(tweet['text'])\n",
      "                with open(\"./data/stream_lunch.json\",\"a\") as archivo:\n",
      "                    archivo.write(json.dumps(tweet, sort_keys=True))\n",
      "                    archivo.write('\\n')\n",
      "            except:\n",
      "                pass\n",
      "        else:\n",
      "            twitter_stream.disconnect()\n",
      "            return\n",
      "    def on_error(self, status):\n",
      "        print(status)\n",
      "\n",
      "\n",
      "twitter_stream = Stream(authentication, TwitterListener())\n",
      "twitter_stream.filter(track=['python'])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "El formato _json_ es conveniente para hacer an\u00e1lisis cuando no necesitamos desplegar en pantalla todos los datos, pero en muchos casos nos gustar\u00eda inspeccionar estos datos manualmente. Si bien un archivo _json_ es un archivo de texto plano, resulta dif\u00edcil de leer; por esta raz\u00f3n vamos a convertir nuestros tweets obtenidos en un archivo _csv_ (valores separados por comas), y de esta manera manipularlos mediante una _hoja de c\u00e1lculo_ ya sea en OpenOffice o Excel. Adem\u00e1s, podemos guardar s\u00f3lo la informaci\u00f3n del tweet que nos interese para reducir el tama\u00f1o de los archivos. El siguiente c\u00f3digo nos muestra como almacenar tweets en un archivo en formato _csv_. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import csv\n",
      "import json\n",
      "\n",
      "fields = ['created_at', 'user', 'text', 'favorite_count', 'retweet_count', 'lang', 'place']\n",
      "\n",
      "tweets = []\n",
      "with open(\"data/stream_lunch.json\") as infile:\n",
      "    for line in infile:\n",
      "        tweet= json.loads(line)\n",
      "        information = []\n",
      "        for field in fields:\n",
      "            if field not in tweet:\n",
      "                information.append('')\n",
      "            elif field == 'user':\n",
      "                information.append(tweet['user']['screen_name'])\n",
      "                information.append(tweet['user']['id'])\n",
      "            elif field == 'place' and tweet['place'] != None:\n",
      "                information.append(tweet['place']['name'])\n",
      "            else:\n",
      "                information.append(tweet[field])\n",
      "        tweets.append(information)\n",
      "\n",
      "with open(\"data/stream_lunch.csv\", \"w\",encoding='utf-8') as outfile:\n",
      "    csvwriter = csv.writer(outfile)\n",
      "    csvwriter.writerow(['created_at', 'screen_name','id', 'text', 'favorite_count', 'retweet_count', 'lang', 'place']) \n",
      "    csvwriter.writerows(tweets)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Notemos que la variable `fields` es una lista que indica los campos de los tweets que queremos almacenar en nuestro archivo con formato _cvs_."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Ejercicio** Actualice esta lista con otros campos."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Ejercicio:** Compara el siguiente c\u00f3digo con el que imprime s\u00f3lo el texto de tweet y se\u00f1ala las diferencias.\n",
      "\n",
      "Podemos extraer y guardar en otro archivo los id de los usuario cuyos tweets colectaste en el archivo `stream_lunch.json` usando el siguiente c\u00f3digo:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Codigo para leer archivos json\n",
      "import json\n",
      "with open('Cuentas.csv','w') as archivo_cuentas:\n",
      "    archivo_cuentas.write('id\\n')\n",
      "    with open(\"./data/stream_lunch.json\",\"r\") as archivo:\n",
      "        renglones=archivo.readlines()\n",
      "        for data in renglones:\n",
      "            tuit=json.loads(data)\n",
      "            archivo_cuentas.write(str(tuit['user']['id'])+'\\n')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# 2.d Clasificar usuarios como _humano_ o _bot_\n",
      "\n",
      "Adem\u00e1s de los datos sobre los usuarios que provee Twitter, tambi\u00e9n tenemos la posibilidad de saber cu\u00e1l es la probabilidad de que un usuario sea _bot_. Antes de esto, veamos una \u00faltima funci\u00f3n de la API que nos permitir\u00e1 tener una idea m\u00e1s precisa de a qu\u00e9 nos referimos\n",
      "\n",
      "#### Twittear desde la API\n",
      "\n",
      "Es posible twittear desde python siguiendo el siguiente c\u00f3digo (despu\u00e9s de haber iniciado sesi\u00f3n desde la API):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Iniciar sesion desde aqui si no se ha hecho previamente\n",
      "\n",
      "mensaje='  ' # Escribir entre las comillas un mensaje\n",
      "\n",
      "api.update_status(status=mensaje) "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Con el c\u00f3digo anterior, resulta casi inmediato saber c\u00f3mo automatizar tweets o respuestas, sin embargo Twitter tambi\u00e9n impone restricciones en el n\u00famero de tweets y en la frecuencia con la que pueden ser enviados. Ignorar estas restricciones conlleva a penalizaciones que van desde un bloqueo temporal de nuestras claves de autorizaci\u00f3n hasta el bloqueo de nuestra cuenta.\n",
      "\n",
      "Mediante los pasos seguidos hasta ahora podr\u00eda automatizarse la interacci\u00f3n de una cuenta de Twitter, de manera que una computadora imite el comportamiento de un usuario humano. A este tipo de programas los llamamos _bots_ y podemos encontrarlos con diferentes grados de sofisticaci\u00f3n. Primero notemos que cada usuario _humano_ de Twitter tiene sus propios h\u00e1bitos para utilizar esta plataforma, y por esta raz\u00f3n encasillar a un usuario como _bot_ o _humano_ involucra probabilidad. Podr\u00edan proponerse muchas maneras de efectuar esta clasificaci\u00f3n, en este curso utilizaremos una funci\u00f3n de Python provista por otro m\u00f3dulo de terceros llamado `Botometer`, ya instaldo anteriormente. "
     ]
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "Utilizando Botometer"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Este m\u00f3dulo utiliza par\u00e1metros como el tipo de contenido y sentimiento en el texto de los tweets, as\u00ed como tu red de amigos, entre otros par\u00e1metros para evaluar la probabilidad de que un usuario sea bot de acuerdo a varios clasificadores. Sin embargo, al ser un m\u00f3dulo desarrollado por la Universidad de Indiana, el clasificador de sentimiento y el de contenido devuelven valores poco confiables debido a que est\u00e1n dise\u00f1ados para trabajar con texto en lengua inglesa. Como hablantes del espa\u00f1ol, podemos utilizar el clasificador de `network`, el cual evalua nuestra la red de la cuenta en terminos de  retweets, menciones y hashtags; el clasificador de `friend` que depende de los seguidores y cuentas seguidas, y el de `temporal`. La descripci\u00f3n completa de los clasificadores podemos encontrarla la documentaci\u00f3n de la primera versi\u00f3n de este m\u00f3dulo _BotOrNot: A System to Evaluate Social Bots_, Clayton, Onu, et.al., _Proceedings of the 25th International Conference Companion on World Wide Web_, 2016, disponible con libre acceso [aqu\u00ed](https://arxiv.org/pdf/1602.00975.pdf).\n",
      "\n",
      "Si tenemos instalado este m\u00f3dulo, podemos correr el siguiente c\u00f3digo que devuelve el puntaje para cada clasificador (puntajes altos representan una probabilidad alta de que la cuenta sea bot y viceversa)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import botometer\n",
      "\n",
      "# Clave Mashape\n",
      "ms_k = \"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\"\n",
      "\n",
      "twitter_app_auth = {\n",
      "    'consumer_key': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "    'consumer_secret': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "    'access_token': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "    'access_token_secret': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "}\n",
      "bom = botometer.Botometer(mashape_key=ms_k, **twitter_app_auth)\n",
      "\n",
      "result = bom.check_account('@usuario')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Notemos que lo anterior solo funciona para un solo usuario, ahora nos interesa saber si \u00bfEs posible hacer la clasificiaci\u00f3n de muchos usuarios al mismo tiempo? La respuesta a lo anterior es s\u00ed y solo debemos hacer lo siguiente:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "accounts = ['@usuario1', '@usuario2', '@usuario3']\n",
      "results = list(bom.check_accounts_in(accounts))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ahora evaluar muchas cuentas de la forma anterior ser\u00eda tedioso y complicado, en lo que sigue explicaremos otra forma de hacerlo y m\u00e1s a\u00fan es posible clasificarlos en seis categor\u00edas:  \n",
      " * Tener los usuarios a evaluar en un archivo `'csv'` que contenga el `'id'` de las cuentas en una columna, supongamos que nuestro archivo se llama `'Cuentas.csv'`.\n",
      " * Cargar los m\u00f3dulos que vamos a usar visualizar la evaluaci\u00f3n de las cuentas:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from __future__ import print_function, unicode_literals\n",
      "\n",
      "import datetime\n",
      "import json\n",
      "import re\n",
      "import time\n",
      "import traceback\n",
      "import botometer\n",
      "import pandas as pd\n",
      "import requests\n",
      "import seaborn as sns\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Ilustraremos el proceso de evaluaci\u00f3n cargando el archivo `'Cuentas.csv'` que contiene el `id` de 30 cuentas:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "file1 = 'Cuentas.csv'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Usando Pandas lo convertimos en un \u00abdata frame\u00bb:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "df = pd.read_csv(file1, low_memory = False, encoding='latin1')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Separamos la columna de los nombres de las cuentas:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "df0 = df['id']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Para darnos una idea r\u00e1pida de las cuentas que tenemos, podemos inspeccionarlas con un `describe`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "df0.describe()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Creamos una lista que tenga solo una menci\u00f3n de cada cuenta a evaluar (para no repetir):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "df3 = df0.unique()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Incluimos las llaves, secretos y pase:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "mashape_key = \"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\"\n",
      "twitter_app_auth = {\n",
      "    'consumer_key': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "    'consumer_secret': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "    'access_token': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "    'access_token_secret': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n",
      "  }\n",
      "\n",
      "for api_key in twitter_app_auth.values(): \n",
      "    assert not api_key.startswith('COPY_')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Ahora inicializamos el API de `Botometer`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "bom = botometer.Botometer(mashape_key=mashape_key, **twitter_app_auth)\n",
      "api = bom.twitter_api"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Ya estamos listos para el paso importante, llamar a `Botometer` usando nuesta lista de cuentas:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import time \n",
      "\n",
      "#time.time() # el tiempo ahora en segundos\n",
      "#time.sleep(10) # se espera durante 10 segundos\n",
      "\n",
      "retry = 0\n",
      "\n",
      "time_at_block_start = time.time()\n",
      "calls_in_block = 0\n",
      "results = {}    \n",
      "for user_id in df3:\n",
      "    try:\n",
      "        print('Getting result for ' , user_id)\n",
      "        bom_result = bom.check_account(user_id)\n",
      "        results[user_id] = bom_result\n",
      "        print('    ...success!')\n",
      "    except:\n",
      "        print('    ...fail.')\n",
      "        \n",
      "    calls_in_block += 1\n",
      "    now = time.time()\n",
      "        \n",
      "    if calls_in_block == 179 and now - time_at_block_start <= 15 * 60:\n",
      "        time.sleep(15 * 60 - now + time_at_block_start)\n",
      "        \n",
      "    if now - time_at_block_start >= 15 * 60:\n",
      "        time_at_block_start = time.time()\n",
      "        calls_in_block = 0\n",
      "\n",
      "print(\"Done.\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Cuando el proceso anterior haya terminado (esto puede demorarse si tenemos muchas cuentas) guardamos los resultados. Para guardar los datos (guardados en memoria como `results`) reutilizaremos el c\u00f3digo que guarda tweets en un archivo:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import json\n",
      "\n",
      "with open(\"./data/evaluacion.json\",'w') as archivo:\n",
      "    for user_id in results.keys():\n",
      "        archivo.write(json.dumps(results[user_id]))\n",
      "        archivo.write('\\n')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Con los pasos anteriores hemos terminado el proceso de la evaluaci\u00f3n de nuestras cuentas mediante Botometer. Ahora ya es posible pasar a la fase de visualizaci\u00f3n simple, para esto:\n",
      " * Abrimos el archivo `'evaluacion.json'` (que creamos con los puntajes) y guardamos la informaci\u00f3n del archivo en la variable `sresultados` (lista que contiene diccionarios):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import json\n",
      "sresults=[]\n",
      "with open(\"./data/evaluacion.json\",\"r\") as archivo:\n",
      "    renglones=archivo.readlines()\n",
      "    for data in renglones:\n",
      "        puntaje=json.loads(data)\n",
      "        sresults.append(puntaje)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Recordemos que como hablantes del espa\u00f1ol el m\u00f3dulo de `Botometer` nos permite podemos utilizar network, el cual evalua nuestra cuenta en t\u00e9rminos de retweets, menciones y hashtags; friend que depende de los seguidores y cuentas seguidas. Ahora preparamos las variables que conformar\u00e1n un nuevo \u00abdata frame\u00bb, el cual utilizaremos para analizar los puntajes obtenidos de `Botometer`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "users = []; content = []; friend = []; network = []; sentiment = []; temporal = []; userc = []\n",
      "for user_dict in sresults:\n",
      "    user=user_dict['user']\n",
      "    users.append(user)\n",
      "    content.append(user_dict['categories']['content'])\n",
      "    friend.append(user_dict['categories']['friend'])\n",
      "    network.append(user_dict['categories']['network'])\n",
      "    sentiment.append(user_dict['categories']['sentiment'])\n",
      "    temporal.append(user_dict['categories']['temporal'])\n",
      "    userc.append(user_dict['categories']['user'])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " * Ahora creamos este nuevo \u00abdata frame\u00bb:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import pandas\n",
      "df = pandas.DataFrame({'user': users, 'content': content, 'friend': friend, 'network': network,\n",
      "  'sentiment': sentiment,\n",
      "  'temporal': temporal,\n",
      "  'user': userc})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "En este momento ya somos capaces de empezar a visualizar los puntajes obtenidos, por ejemplo en la categor\u00eda de \u00abNetwork\u00bb, usando un estimado de la densidad de n\u00facleo, conocido como \u00abkernel density estimate\u00bb, adem\u00e1s la imagen se guardar\u00e1 en un archivo:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from __future__ import print_function, unicode_literals\n",
      "\n",
      "import datetime\n",
      "import json\n",
      "import re\n",
      "import time\n",
      "import traceback\n",
      "import botometer\n",
      "import pandas as pd\n",
      "import requests\n",
      "import seaborn as sns\n",
      "\n",
      "import numpy as np\n",
      "\n",
      "import matplotlib.pyplot as plt\n",
      "\n",
      "scores = df[df['network'].notnull()]['network']\n",
      "sns.set(rc={\"figure.figsize\": (12, 6)})\n",
      "ax = sns.distplot(scores)\n",
      "ax.set_title('Distribuci\u00f3n de puntajes de Red, \u00abNetwork\u00bb, obtenidos con Botometer en Cuentas.csv')\n",
      "ax.set_xlim([0,1])\n",
      "ax.set_xlabel('Content classification')\n",
      "ax.yaxis.set_visible(True)\n",
      "ax.patch.set_visible(True)\n",
      "\n",
      "filename = 'Network-Cuentas'\n",
      "plt.savefig(filename)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Por cuestiones de tiempo, s\u00f3lo hemos evaluado 30 cuentas; un ejemplo de una gr\u00e1fica obtenida evaluando un mayor n\u00famero de cuentas se muestra en la siguiente imagen. Para este ejemplo se colectaron tweets usando la etiqueta _#Tanhuato_: \n",
      "\n",
      "![](Network-dist-Tanhuato_19-20_8_16.png)\n",
      "\n",
      "Vemos una se\u00f1al prominente en .8, lo que indica que estas cuentas son muy probablemente bots y que ademas tienen las mismas caracter\u00edsticas, lo cu\u00e1l suceder\u00eda si todas fueron automatizadas (programadas) con los mismos par\u00e1metros de comportamiento.\n",
      "\n",
      "Distintas cuentas se comportan de distintas maneras, por lo que es conveniente comparar varios puntajes a la vez. Esto es sencillo en 2D. Por ejemplo, comparemos puntajes de Red y Amigos:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "sns.set(style=\"white\")\n",
      "\n",
      "x1 = df[df['friend'].notnull()]['friend']\n",
      "x2 = df[df['network'].notnull()]['network']\n",
      "x1 = pd.Series(x1, name=\"Friend class\")\n",
      "x2 = pd.Series(x2, name=\"Net class\")\n",
      "\n",
      "g = sns.jointplot(x1, x2, kind=\"kde\", n_levels=60, shade=True, size=12, space=0)\n",
      "\n",
      "filename = 'KDE-Friend-Temporal-Cuentas'\n",
      "plt.savefig(filename)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Como antes, ilustramos con un ejemplo obtenido de un conjunto de datos m\u00e1s extenso (_#Tanhuato_):\n",
      "\n",
      "![](KDE-Friend-Net-Tanhuato_19-20_8_16.png)\n",
      "\n",
      "Se aprecia un c\u00famulo de cuentas con una distribuci\u00f3n muy uniforme en la esquina superior derecha, la zona de los bots.\n",
      "\n",
      "De esta manera podemos identificar c\u00famulos de cuentas que son potencialmente bots dejando que los datos gu\u00eden el an\u00e1lisis.\n",
      "\n",
      "Estos m\u00e9todos fueron desarrollados para [\u00e9ste art\u00edculo](https://link.springer.com/chapter/10.1007/978-3-319-47874-6_19), disponible con [libre acceso aqu\u00ed](https://arxiv.org/abs/1609.08239).\n",
      "\n",
      "**Su\u00e1rez-Serrato, Pablo, Margaret E. Roberts, Clayton Davis, and Filippo Menczer. \"On the influence of social bots in online protests.\" In International Conference on Social Informatics, pp. 269-278. Springer International Publishing, 2016.**\n",
      "\n",
      "**Nota:** Los autores agradecen que [se cite](http://dblp.uni-trier.de/rec/bibtex/journals/corr/Suarez-SerratoR16) este trabajo si se usan estos m\u00e9todos o c\u00f3digos."
     ]
    }
   ],
   "metadata": {}
  }
 ]
}