Esercitazione Guidata sul Web Scraping.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import json\n",
    "from bs4 import BeautifulSoup as bs\n",
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warm-up: 5 Esercizi in 30 minuti (in media)\n",
    "\n",
    "#### Esercizio 1\n",
    "A partire dalla lista _inizio_ si crei una nuova lista i cui elementi corrispondono alle lunghezze di ogni singola stringa nella lista.\n",
    "\n",
    "```\n",
    "Output: [2, 6, 9, 8, 1, 9, 5, 6, 3, 10, 2, 5]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 6, 9, 8, 1, 9, 5, 6, 3, 10, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "inizio = ['in','questo','esercizio','contiamo','i','caratteri','delle','parole','che','compongono','la','lista']\n",
    "# Modo Python Base\n",
    "out = []\n",
    "for e in inizio:\n",
    "    out.append(len(e))\n",
    "print(out)\n",
    "\n",
    "# Modo Python intermedio = List comprehension\n",
    "out_2 = [len(e) for e in inizio]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 2\n",
    "Si crei una stringa partendo dalla lista inizio composta dalla concatenazione delle parole contenute nella lista separate da uno spazio. Si utilizzi il metodo **join**\n",
    "\n",
    "```\n",
    "Output: 'in questo esercizio contiamo i caratteri delle parole che compongono la lista'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'in questo esercizio contiamo i caratteri delle parole che compongono la lista'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "' '.join(inizio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 3\n",
    "Si legga il file in formato JSON 'data/warmup.json' e si acceda al valore associato alla chiave _esercizio_ \n",
    "\n",
    "```\n",
    "Output: Esercizio 5\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Esercizio 5'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "json.load(open('data/warmup.json'))['esercizio']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 4\n",
    "Si crei un dictionary composto dalle chiavi 'uno', 'due' e 'tre' inizializzati al valore 0. Si implementi, poi un ciclo for di 10 iterazioni che incrementi i valori associati alle tre chiavi\n",
    "\n",
    "```\n",
    "Output: {'uno':10, 'due':10, 'tre':10}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'uno': 10, 'due': 10, 'tre': 10}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'due': 0, 'tre': 0, 'uno': 0}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'uno':0, 'due':0, 'tre':0}\n",
    "for i in range(10):\n",
    "    d['uno'], d['due'], d['tre'] = d['uno'] + 1, d['due'] + 1, d['tre'] + 1\n",
    "print(d)\n",
    "\n",
    "d2 = {e:0 for e in ['uno','due','tre']}\n",
    "d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 5\n",
    "Si estragga il valore associato alla chiave _esecizio_ nel file 'data/warmup.json' utilizzando solo i metodi della classe _string_\n",
    "\n",
    "```\n",
    "Output: Esercizio 5\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esercizio 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Esercizio 5'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open('data/warmup.json') as f:\n",
    "    js = f.read()\n",
    "js_1 = js[js.index('esercizio')+len('esercizio: ')+2:]\n",
    "js_2 = js_1[:js_1.index(',')-1]\n",
    "print(js_2)\n",
    "\n",
    "# Singola riga\n",
    "js[js.index('esercizio\": \"')+len('esercizio\": \"') : js.index('\",',js.index('esercizio\":'))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 6\n",
    "Il file 'data/test.js' contiene un breve script in Javascript. Si estragga la lista Javascript e la si trasformi in una lista Python utilizzando il modulo **json**\n",
    "\n",
    "```\n",
    "Output: [2,4,5,6,3,2,5,4,3]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> [2, 4, 5, 6, 3, 2, 5, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "with open('data/test.js') as f:\n",
    "    jsf = f.read()\n",
    "lista = json.loads(jsf[jsf.index('['):jsf.index(']')+1])\n",
    "print(type(lista), lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 7\n",
    "Si scarichi la pagina www.google.it e si conti quante volta la stringa 'Google' occorre nella pagina\n",
    "\n",
    "```\n",
    "Output: 7 (puo' variare)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "requests.get('https://www.google.it').text.count('Google')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 8\n",
    "Si richieda la risorsa associata all'URL https://postman-echo.com/get?foo1=bar1&foo2=bar2 e si ottega la stringa associata alla chiave _cookies_\n",
    "\n",
    "```\n",
    "Output:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python-requests/2.18.4'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "requests.get('https://postman-echo.com/get?foo1=bar1&foo2=bar2').json()['headers']['user-agent']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 9\n",
    "Si esegua una richiesta HTTP con il metodo POST alla risorsa https://postman-echo.com/post inviando le chiavi 'nome' e 'cognome', a cui corrispondono nome e cognome dello studente. Si acceda al campo 'form' della risposta.\n",
    "\n",
    "```\n",
    "Output:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cognome': 'Cotugno', 'nome': 'Toto'}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "requests.post('https://postman-echo.com/post', data = {'nome': 'Toto', 'cognome': 'Cotugno'}).json()['form']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Esercizio 10\n",
    "Si scarichino le slides della prima lezione disponibili qui - http://someni.di.unimi.it/slide/2018/Introduzione%20al%20corso.pdf - salvandole nel file 'primaLezione.pdf'.\n",
    "\n",
    "```\n",
    "Output:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('primaLezione.pdf','wb') as f:\n",
    "    f.write(requests.get('http://someni.di.unimi.it/slide/2018/Introduzione%20al%20corso.pdf').content)\n",
    "\n",
    "f = open('primaLezione2.pdf','wb')\n",
    "f.write(requests.get('http://someni.di.unimi.it/slide/2018/Introduzione%20al%20corso.pdf').content)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Esercitazione\n",
    "In questa esercitazione utilizzeremo le nozioni presentate nella lezione di laboratorio \"Web Scraping\" applicandole al social media WANELO (https://wanelo.co/), un social media rivolto allo shopping e alla moda.\n",
    "<img src='figures/hello.png'>\n",
    "\n",
    "Gli obiettivi dell'esercitazione sono  i seguenti:\n",
    "- loggarsi nel sistema attraverso il modulo **requests**\n",
    "- estrarre gli oggetti per uomo messi in vendita nella sezione 'Trending'\n",
    "- estrarre i folllower/following di un utente\n",
    "\n",
    "## Passo 0\n",
    "Il primo passo è iscriversi al social media. E' possibile registrarsi a WANELO all'indirizzo https://wanelo.co/users/sign_in e cliccando sul link \"Not a member yet? Join us!\". Per registrarsi vi vengono richiesti un'indirizzo e-mail, uno username e una password (da non dimenticare).\n",
    "\n",
    "## Obiettivo 1: Effettuare il login nel sistem\n",
    "Il form di login è raggiungibile all'indirizzo https://wanelo.co/users/sign_in\n",
    "<img src='figures/login2.png'>\n",
    "\n",
    "### a) Ispezionare il codice del form\n",
    "Cliccare col tasto destro sul form di login e selezionare \"Ispeziona\". Si apre la console di Chrome. Selezionare il tab \"Elements\" se non è gia selezionato. \n",
    "\n",
    "Il file <a href='data/form_login.html' target='_blank'>*form_login.html*</a> contiene il codice del form.\n",
    "\n",
    "Analizzando il codice HTML si completino le seguenti celle di codice:\n",
    "- Qual è l'url a cui vengono inviati i dati del form?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "url_action = 'https://wanelo.co/users/sign_in'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Quanti sono i campi input? Quanti sono hidden? Quali sono i loro nomi? Quali sono i valori associati?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_data = {'utf8':'&#x2713;',\n",
    "             'authenticity_token':'',\n",
    "              'user[login]': 'USERNAME',\n",
    "              'user[password]': 'PASSWORD',\n",
    "              'user[remember_me]': 'true',\n",
    "              'commit': 'Sign in'\n",
    "             }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imprevisto\n",
    "Rispetto al form visto a lezione, il campo authenticity_token ha un valore non definito ('XXXXXX'). \n",
    "\n",
    "Il valore associato all'attributo viene caricato dinamicamente.\n",
    "\n",
    "Utilizzando i DevTools di Chrome (tab 'Network') e il codice HTML della pagina https://wanelo.co/users/sign_in ( CTRL+U in Chrome per ottenere il codice sorgente della pagina) si puo' comprendere come ottenere il valore associato all'attributo *authenticity_token*. \n",
    "\n",
    "Una volta capito come ottenere il valore, si crei un oggetto Session:\n",
    "\n",
    "**N.B.** Tutte le richieste devono essere effettuate attraverso  l'oggetto Session creato"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sessione_wanelo = requests.Session()\n",
    "sessione_wanelo.headers.update({'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36',\n",
    "                               'DTN':'1',\n",
    "                               'Referer':'https://wanelo.co/users/sign_in'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si richieda la pagina di login indicata nelle precedenti istruzioni. La variabile sign_in_page deve contenere il testo (non utilizzare l'attributo content ma **text**) della pagina di login:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sign_in_page = sessione_wanelo.get('https://wanelo.co/users/sign_in').text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si trasformi il testo della pagina in un oggetto BeautifulSoup:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sign_in_albero = bs(sign_in_page,'lxml')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si estragga il valore da assegnare al campo *authenticity_token*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_data['authenticity_token'] = sign_in_albero.find('meta',{'name':'csrf-token'}).attrs['content']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) Loggarsi nel sistema\n",
    "\n",
    "Una volta individuato l'url e i parametri da inviare si deve inviare una richiesta HTTP di tipo POST all'url individuato"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si esegua la richiesta HTTP. In caso di login corretto si deve ricevere una risposta con codice 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_ssn': 'f8a48831d254a2e792de49fb280b7155'}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sessione_wanelo.post(url_action, data=input_data, allow_redirects=False).cookies.get_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per verificare se l'utente è effettivamente loggato, cerchiamo se la stringa corrispondente al nostro username è presente nella pagina https://wanelo.co/username"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problema\n"
     ]
    }
   ],
   "source": [
    "test_page = sessione_wanelo.get('https://wanelo.co/settings').text\n",
    "if 'matteo_zignani' in test_page:\n",
    "    print('Non ci sono problemi')\n",
    "else:\n",
    "    print('Problema')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Obiettivo 2: Estrarre gli oggetti nella sezione 'Trending' per la categoria \"home\"\n",
    "\n",
    "Per raggiungere il secondo obiettivo si procede con l'estrazione degli oggetti messi in vendita nella sezione 'Trending' https://wanelo.co/trending?c=home. Attraverso il parametro 'c' si specifica che si vogliono gli oggetti della categoria \"home\".\n",
    "\n",
    "### a) individuare il valore dell'attributo class attraverso il quale posso identificare il tag div che contiene le informazioni dell'oggetto messo in vendita\n",
    "\n",
    "Si ispezioni il codice HTML della pagina https://wanelo.co/trending?c=home attraverso la funzione **Inspect** di Chrome.\n",
    "Una volta individuato il valore dell'attributo 'class', si estraggano le seguenti informazioni:\n",
    "<img src='figures/item.png'>\n",
    "- il nome dell'oggetto (evidenziato in rosso)\n",
    "- l'utente che ha postato l'oggetto (evidenziato in verde)\n",
    "- il negozio che mette in vendita l'oggetto (evidenziato in azzuro)\n",
    "- il prezzo dell'oggetto (evidenziato in giallo)\n",
    "- quante volte e' stato salvato l'oggetto (evidenziato in viola)\n",
    "\n",
    "### b) la funzione get_info\n",
    "Si implementi la funzione **get_info** che restituisce un dictionary costituito da cinque chiavi: \n",
    "- item \n",
    "- user\n",
    "- shop\n",
    "- price\n",
    "- saved \n",
    "\n",
    "La funzione riceve come unico argomento l'elemento div individuato al punto 2.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_info(div_item):\n",
    "    out = dict()\n",
    "    out['item'] = div_item.find('div',{'class':'name'}).a.text\n",
    "    try:\n",
    "        out['user'] = div_item.find('div',{'class':'poster'}).a.attrs['href'][1:]\n",
    "    except AttributeError:\n",
    "        pass\n",
    "    out['shop'] = div_item.find('div',{'class':'store'}).a.attrs['href'][1:]\n",
    "    out['price'] = div_item.find('div',{'class':'store'}).span.text\n",
    "    out['saved'] = div_item.find('span',{'class':'js-saves-count'}).text\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) Richiesta della pagina dei trending\n",
    "Si richieda la pagina degli oggetti per uomo nella sezione 'Trending'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "trending_page = bs(sessione_wanelo.get('https://wanelo.co/trending?c=home').text,'lxml')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d) il ciclo di estrazione\n",
    "Si iteri sui tag 'div' individuati al punto 2.a e si estraggano le informazioni utilizzando la funzione precedentemente definita. Ogni dictionary restituito deve essere inserito in una lista 'item_info'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "item_info = []\n",
    "for element in trending_page.findAll('div',{'class':'product-card'}):\n",
    "    info = get_info(element)\n",
    "    item_info.append(info)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### e) Costruzione dell'insieme dei nodi (seed) da cui far partire la visita della rete sociale\n",
    "Si crei una lista di url di utenti partendo dalle informazioni contenute in 'item_info'. Per esempio, da una entry del tipo \n",
    "```python\n",
    "{\n",
    "    'user': 'pippo'\n",
    "    'item' : 'Lampada Ikea Akldskps'\n",
    "}\n",
    "```\n",
    "viene generato l'URL https://wanelo.co/pippo. Per eliminare eventuali ripetizioni si utilizzi il costruttore **set()** per costruire un insieme ricevendo come argomento una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = set(['https://wanelo.com/'+element['user'] for element in item_info if 'user' in element])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Obiettivo 3: Estrarre i follower di un utente\n",
    "Per completare il terzo obiettivo dobbiamo estrarre i follower di un utente. In particolare, per ogni follower dobbiamo identificare il suo account name, ossia l'url del profilo dell'utente in Wanelo (es. https://wanelo.co/dg424).\n",
    "\n",
    "### a) Identificare il valore dell'attributo class del tag 'div' che include le informazioni di un singolo follower\n",
    "Aprire l'url che restituisce i follower di un utente, scelto in modo casuale; per esempio, https://wanelo.co/dg424/followers.<br>\n",
    "Ispezionare il codice della pagina per trovare il tag 'div' che contiene le informazioni di un singolo follower. Il codice HTML è riportato anche nel file 'follower-item.html'\n",
    "\n",
    "### b) Implementare la funzione get_followers()\n",
    "La funzione **get_followers** riceve come argomento l'account name e restituisce una lista deli followers (account name). Il numero massimo di followers ottenibili e' 60."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_followers(session, username, max_followers = 60):\n",
    "    followers = []\n",
    "    page = bs(session.get(username+'/followers').text,'lxml')\n",
    "    count = 2\n",
    "    while len(followers) < max_followers:\n",
    "        search = page.findAll('div',{'class':'followable-resource'})\n",
    "        if search:\n",
    "            for element in search:\n",
    "                followers.append(element.find('a',{'class':'preview-strip-description-avatar'}).attrs['href'][1:]) \n",
    "            page = bs(session.get(username+'/followers/'+str(count)).text,'lxml')\n",
    "            count += 1\n",
    "        else:\n",
    "            break\n",
    "    return followers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = get_followers(sessione_wanelo,'https://wanelo.co/dg424')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) Per ogni utente nel seed si ottengano i followers\n",
    "... utilizzando la funzione definita in precedenza"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "followers_per_users = {username : get_followers(sessione_wanelo,username) for username in seed}"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}