{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Программирование на языке Python для сбора и анализа данных\n",
    "\n",
    "*Текст лекции: Будылин Р.Я., Щуров И.В., НИУ ВШЭ*\n",
    "\n",
    "Данный notebook является конспектом лекции по курсу «Программирование на языке Python для сбора и анализа данных» (НИУ ВШЭ, 2015-16). Он распространяется на условиях лицензии [Creative Commons Attribution-Share Alike 4.0](http://creativecommons.org/licenses/by-sa/4.0/). При использовании обязательно упоминание автора курса и аффилиации. При наличии технической возможности необходимо также указать активную гиперссылку на [страницу курса](http://math-info.hse.ru/s15/m). Фрагменты кода, включенные в этот notebook, публикуются как [общественное достояние](http://creativecommons.org/publicdomain/zero/1.0/).\n",
    "\n",
    "Другие материалы курса, включая конспекты и видеозаписи лекций, а также наборы задач, можно найти на [странице курса](http://math-info.hse.ru/s15/m)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JSON и API. Управление браузером в RoboBrowser и Selenium "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Работа с API с помощью JSON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В [прошлый раз](http://nbviewer.ipython.org/github/ischurov/pythonhse/blob/master/Lecture%209.ipynb#%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B0%D0%B5%D0%BC-%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA-%D1%81%D1%82%D0%B0%D1%82%D0%B5%D0%B9-%D0%B8%D0%B7-%D0%BA%D0%B0%D1%82%D0%B5%D0%B3%D0%BE%D1%80%D0%B8%D0%B8-%D0%B2-%D0%92%D0%B8%D0%BA%D0%B8%D0%BF%D0%B5%D0%B4%D0%B8%D0%B8) мы обсуждали работу с API. При этом для получения информации от API использовался формат XML. Помимо XML существует другой распространённый формат хранения и передачи структурированной информации, называющийся JSON. JSON расшифровывается как JavaScript Object Notation и изначально возник как подмножество языка JavaScript (пусть вас не вводит в заблуждение название, этот язык ничего не имеет общего с Java), используемое для описания объектов, но впоследствии стал использоваться и в других языках программирования, включая Python. Различные API могут поддерживать либо XML, либо JSON, либо и то, и другое, так что нам полезно научиться работать с обоими типами данных. Поэтому мы рассмотрим пример чтения данных из Википедии как в прошлый раз, но будем использовать формат JSON — на наше счастье, API MediaWiki это позволяет.\n",
    "\n",
    "Напомним, что нашей задачей является получение списка всех статей из некоторой категории в Википедии. Вот так мы это делали в прошлый раз:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "url = \"https://en.wikipedia.org/w/api.php\"\n",
    "params = {\n",
    "    'action':'query',\n",
    "    'list':'categorymembers',\n",
    "    'cmtitle': 'Category:Physics',\n",
    "    'format': 'xml'\n",
    "}\n",
    "\n",
    "g = requests.get(url, params=params)\n",
    "g.ok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как и в прошлый раз, мы взяли эти параметры из [документации](https://www.mediawiki.org/wiki/API:Categorymembers): `'action': 'query'` значит, что мы отправляем запрос, чтобы получить содержимое Википедии. Параметр `list` отвечает на вопрос список чего мы бы хотели получить. В данном случае это `categorymembers` — список элементов какой-то категории, `cmtitle` — это название категории, список элементов которой мы хотим получить. `'format'` — это формат ответа, который в прошлый раз был `xml`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data = BeautifulSoup(g.text, features='xml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Physics\n",
      "Branches of physics\n",
      "Glossary of classical physics\n",
      "Outline of physics\n",
      "Portal:Physics\n",
      "Classical physics\n",
      "Epicatalysis\n",
      "Experimental physics\n",
      "Hume Feldman\n",
      "Microphysics\n"
     ]
    }
   ],
   "source": [
    "for cm in data.api.query.categorymembers(\"cm\"):\n",
    "    print(cm['title'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем теперь использовать JSON. Отличия в способе вызова минимальны: в качестве `format` указываем `json`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = \"https://en.wikipedia.org/w/api.php\"\n",
    "params = {\n",
    "    'action':'query',\n",
    "    'list':'categorymembers',\n",
    "    'cmtitle': 'Category:Physics',\n",
    "    'format': 'json'\n",
    "}\n",
    "\n",
    "g = requests.get(url, params=params)\n",
    "g.ok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Смотрим, что нам выдали по запросу. Это и есть JSON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"batchcomplete\":\"\",\"continue\":{\"cmcontinue\":\"page|4d4f4445524e20504859534943530a4d4f4445524e2050485953494353|844186\",\"continue\":\"-||\"},\"query\":{\"categorymembers\":[{\"pageid\":22939,\"ns\":0,\"title\":\"Physics\"},{\"pageid\":22688097,\"ns\":0,\"title\":\"Branches of physics\"},{\"pageid\":3445246,\"ns\":0,\"title\":\"Glossary of classical physics\"},{\"pageid\":24489,\"ns\":0,\"title\":\"Outline of physics\"},{\"pageid\":1653925,\"ns\":100,\"title\":\"Portal:Physics\"},{\"pageid\":151066,\"ns\":0,\"title\":\"Classical physics\"},{\"pageid\":47723069,\"ns\":0,\"title\":\"Epicatalysis\"},{\"pageid\":685311,\"ns\":0,\"title\":\"Experimental physics\"},{\"pageid\":48407923,\"ns\":0,\"title\":\"Hume Feldman\"},{\"pageid\":23581364,\"ns\":0,\"title\":\"Microphysics\"}]}}'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Он очень похож на описание объекта в Python и смысл квадратных и фигурных скобок такой же. Правда, есть и отличия: например, в Python одинарные и двойные кавычки ничем не отличаются, а в JSON можно использовать только двойные. Мы видим, что полученный нами JSON представляет собой словарь, значения которого — строки или числа, а также списки или словари, значения которых в свою очередь также могут быть строками, числами, списками, словарями и т.д. То есть получается такая довольно сложная структура данных. \n",
    "\n",
    "В данный момент тот факт, что перед нами сложная структура данных, видим только мы — с точки зрения Python, `r.text` это просто такая строка. Однако в модуле `requests` есть метод, позволяющий сразу выдать питоновский объект (словарь или список), если результат запроса возвращён в формате JSON. Так что нам не придётся использовать никакие дополнительные библиотеки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "q = r.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видим, что q это словарь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'batchcomplete': '',\n",
       " 'continue': {'cmcontinue': 'page|4d4f4445524e20504859534943530a4d4f4445524e2050485953494353|844186',\n",
       "  'continue': '-||'},\n",
       " 'query': {'categorymembers': [{'ns': 0, 'pageid': 22939, 'title': 'Physics'},\n",
       "   {'ns': 0, 'pageid': 22688097, 'title': 'Branches of physics'},\n",
       "   {'ns': 0, 'pageid': 3445246, 'title': 'Glossary of classical physics'},\n",
       "   {'ns': 0, 'pageid': 24489, 'title': 'Outline of physics'},\n",
       "   {'ns': 100, 'pageid': 1653925, 'title': 'Portal:Physics'},\n",
       "   {'ns': 0, 'pageid': 151066, 'title': 'Classical physics'},\n",
       "   {'ns': 0, 'pageid': 47723069, 'title': 'Epicatalysis'},\n",
       "   {'ns': 0, 'pageid': 685311, 'title': 'Experimental physics'},\n",
       "   {'ns': 0, 'pageid': 48407923, 'title': 'Hume Feldman'},\n",
       "   {'ns': 0, 'pageid': 23581364, 'title': 'Microphysics'}]}}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Содержательная информация хранится по ключу `'query'`. А уже внутри есть ключ `'categorymembers'`, значением которого является список всех категорий. Каждая категория отображается в виде словаря, записями которого являются разные параметры категории (например, `'title'` соответствует названию, а `pageid` — внутреннему идентификатору в системе)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(q['query']['categorymembers'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это список всех членов категории. Мы можем посмотреть на них с помощью цикла"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Physics\n",
      "Branches of physics\n",
      "Glossary of classical physics\n",
      "Outline of physics\n",
      "Portal:Physics\n",
      "Classical physics\n",
      "Epicatalysis\n",
      "Experimental physics\n",
      "Hume Feldman\n",
      "Microphysics\n"
     ]
    }
   ],
   "source": [
    "for cm in q['query']['categorymembers']:\n",
    "    print(cm['title'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Преимущества JSON в том, что мы получаем готовый объект Python и нет необходимости использовать какие-то дополнительные библиотеки для того, чтобы с ним работать. Недостатком является то же самое: зачастую поиск информации в XML-файле может проводиться более эффективно, чем в JSON. Продемонстрируем это на уже рассмотренном примере. Чтобы получить список всех тегов `<cm>`, в которых хранилась информация об элементах категории в XML, мы использовали полный «путь»: \n",
    "```python\n",
    "for cm in data.api.query.categorymembers(\"cm\"):\n",
    "    print(cm['title'])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако, это можно бы сделать (в данном случае) гораздо короче. Если посмотреть на XML, то можно заметить, что в нём нет других тегов `<cm>`, кроме тех, которые нам нужны. С другой стороны, *Beautiful Soup* ищет все теги с данным именем, а не только те, которые являются потомками первого уровня для данного тега. Таким образом, код выше можно было бы переписать более коротко:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Physics\n",
      "Branches of physics\n",
      "Glossary of classical physics\n",
      "Outline of physics\n",
      "Portal:Physics\n",
      "Classical physics\n",
      "Epicatalysis\n",
      "Experimental physics\n",
      "Hume Feldman\n",
      "Microphysics\n"
     ]
    }
   ],
   "source": [
    "for cm in data(\"cm\"):\n",
    "    print(cm['title'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Конечно `data(\"cm\")` выглядит короче, чем `q['query']['categorymembers']`. В JSON мы не можем использовать подобные методы. Так что у обоих форматов есть свои плюсы и минусы."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Эмуляция действий с браузером"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда нам нужно не просто скачать какую-нибудь информацию с сайта, а сделать что-то более сложное: например, залогиниться по своим аккаунтом, перейти на какую-то страницу, найти на ней ссылку, перейти по этой ссылке и скачать какую-то информацию. Продемонстрируем два инструмента для решения этой задачи: `robobrowser` и `selenium`.\n",
    "\n",
    "Рассмотрим эту задачу на примере работы с сервисом `informatics.mccme.ru`, который мы использовали для сдачи задач в начале нашего курса. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### RoboBrowser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пакет `robobrowser` позволяет работать с неким виртуальным браузером, который позволяет ходить по страничкам и получать их содержимое. На самом деле, этот браузер полностью эмулируется Python: фактически `robobrowser` представляет собой надстройку над `requests` и `BeautifulSoup`, позволяющую несколько упростить типичные операции типа «найти ссылку и пройти по ней»."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from robobrowser import RoboBrowser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вдруг Python ругается, что нет каких-то модулей, то сделайте `pip install имя_модуля` в консоли."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "q = RoboBrowser()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы создали виртуальный браузер."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ref = 'http://informatics.mccme.ru'\n",
    "q.open(ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И сказали ему открыть ссылку. Мы можем посмотреть на html содержимое страницы командой ниже"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Дистанционная подготовка\n",
      "//<![CDATA[\n",
      "setTimeout('fix_column_widths()', 20);\n",
      "function openpopup(url,name,options,fullscreen) {\n",
      "  fullurl = \"http://informatics.mccme.ru\" + url;\n",
      "  windowobj = window.open(fullurl,name,options);\n",
      "  if (fullscreen) {\n",
      "     windowobj.moveTo(0,0);\n",
      "     windowobj.resizeTo(screen.availWidth,screen.availHeight);\n",
      "  }\n",
      "  windowobj.focus();\n",
      "  return false;\n",
      "}\n",
      "function uncheckall() {\n",
      "  void(d=document);\n",
      "  void(el=d.getElementsByTagName('INPUT'));\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/site-packages/bs4/__init__.py:166: UserWarning: No parser was explicitly specified, so I'm using the best available HTML parser for this system (\"lxml\"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.\n",
      "\n",
      "To get rid of this warning, change this:\n",
      "\n",
      " BeautifulSoup([your markup])\n",
      "\n",
      "to this:\n",
      "\n",
      " BeautifulSoup([your markup], \"lxml\")\n",
      "\n",
      "  markup_type=markup_type))\n"
     ]
    }
   ],
   "source": [
    "# мне пришлось немного поколодовать, чтобы вывод получился не слишком длинным, \n",
    "# но можно было написать просто\n",
    "# print(q.parsed.text)\n",
    "\n",
    "for l in q.parsed.text.splitlines()[0:50]:\n",
    "    # выведем первые несколько строк\n",
    "    if l.strip():\n",
    "        # пропустим пустые строки\n",
    "        \n",
    "        print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Не пугайтесь красного *warning* выше — просто *Beautiful Soup* предупреждает, что мы (а точнее разработчики RoboBrowser) не указали ему, какой парсер использовать, и он использовал самый лучший из доступных (с его точки зрения).\n",
    "\n",
    "Найдём ту форму, которая соответствует вводу пароля. В браузере с помощью просмотра кода элемента, мы можем посмотреть кусок HTML, соответствующий форме ввода логина и пароля и узнать у неё есть атрибут `id = 'login'` (атрибут `id` похож на атрибут `class`, но отличается уникальностью: существует ровно один элемент на странице с данным `id`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Форма ввода логина и пароля](http://math-info.hse.ru/f/2015-16/all-py/informatics-login.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Извлечем эту форму в *RoboBrowser*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "form = q.get_form(id='login')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нам естественно понадобятся логин и пароль от informatics. Чтобы не сохранять их в исходнике программы, я введу их с клавиатуры."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "login = input()\n",
    "password = input()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Элемент `form` ведёт себя как словарь и вы можете передать ему ваши логин и пароль вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "form['username'] = login\n",
    "form['password'] = password"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь посылаем заполненную форму браузеру."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "q.submit_form(form)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Проверяем, что мы залогинились и наша фамилия или имя есть на странице"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Okay, you are logged in\n"
     ]
    }
   ],
   "source": [
    "name = \"Щуров\"\n",
    "if name in q.response.text:\n",
    "    print(\"Okay, you are logged in\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, мы залогинились и продемонстрировали, как совершать простейшие действия с помощью *RoboBrowser*. Дальше можно искать ссылки и переходить по ним, заполнять формы и т.д. В общем, RoboBrowser довольно удобен для простых задач, связанных с обращением к сайтам. Однако для дальнейшего нам потребуется инструмент помощнее…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Selenium"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Давным-давно, в одной далёкой-далёкой галактике…\n",
    "\n",
    "Когда-то давно трава была зеленой, деревья высокими, а Веб состоял из статических HTML-страниц. Его можно было только читать — ну и выкладывать новые HTML-страницы на сервер, если вы знали, как это делается. Потом появились разные интерактивные страницы типа форумов и первых блогов. Работали они примерно так: вы заходили на сайт, ваш браузер скачивал соответствующую страницу. Там можно было кликнуть по какой-то ссылке или заполнить какую-то форму (например, написать комментарий к посту). В ответ сервер генерировал новую HTML-страницу, браузер её снова загружал и т.д. При этом страница перезагружалась целиком, даже если там изменился всего один символ. Это было дико долго и неэффективно. \n",
    "\n",
    "Потом появились новые технологии, которые позволили веб-странице обновляться «кусочками». Для этого в них стали встраивать помимо HTML-кода также код на языке JavaScript. В отличие от HTML, являющегося лишь языком разметки текста, язык JavaScript является полноценным императивным языком программирования (по своим возможностям он похож на Python) и с его помощью можно делать много разных вещей. В частности, в ответ на действие пользователя (например, клик по ссылке или кнопке) отправить какую-то информацию серверу, получить  ответ и поменять в соответствии с этим ответом страничку, которая отображается в данный момент, не перезагружая её целиком. Благодаря этому, например, отправив комментарий в социальной сети мы тут же видим, как оно появилось, не перезагружая всю ленту целиком.\n",
    "\n",
    "Но есть и тёмная сторона Силы. Современные веб-страницы бывает очень сложно обрабатывать как раз из-за того, что они генерируются динамически на стороне клиента (то есть пользователя). В частности, используемый нами RoboBrowser не умеет запускать JavaScript. А информация о посылках на informatics как раз именно им и генерируется — об этом свидетельствует тот факт, что после открытия соответствующей страницы её центральная часть отображается не сразу — сначала там крутится индикатор (в этот момент как раз JavaScript запрашивает информацию у сервера).\n",
    "\n",
    "#### Selenium: дистанционное управление для браузера\n",
    "\n",
    "Однако, не следует отчаиваться: нам поможет другой пакет, называемый *Selenium*. Он не запускает JavaScript сам, зато он умеет управлять браузерами, в том числе тем который уже установлен у вас.\n",
    "\n",
    "Допустим, что нам надо скачать результаты наших посылок (на лекции скачивали результаты участников факультатива, но я не уверен, что они доступны для студентов). Здесь я буду скачивать результаты своих посылок, эти задачи аналогичны."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from selenium import webdriver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Откроем браузер с помощью *Selenium*. Для этого нужно чтобы у вас был установлен данный браузер. В моем случае это Firefox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "browser = webdriver.Firefox()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видим, что открылось окошко браузера. Перейдем на informatics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ref = 'http://informatics.mccme.ru'\n",
    "browser.get(ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Найдем форму входа на сайт"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "form = browser.find_element_by_id('login')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Логика здесь примерно такая же, как в `RoboBrowser` (а у него она заимствована из *Beautiful Soup*), хотя названия методов различаются.\n",
    "\n",
    "Найдем у этой формы элементы, отвечающие логину и паролю,  и введём в них наши данные. Имейте в виду, что informatics может узнать вас и поле username может быть уже заполненным. Тогда нужно вводить только пароль. Следует отметить, что *Selenium* вводит данные в форму, эмулируя нажатия на кнопки, поэтому если в форме что-то уже записано, то дополнительные символы припишутся к уже существующим. Для безопасности мы на всякий случай очистим поле, прежде, чем что-то туда писать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "un = form.find_element_by_name('username')\n",
    "un.clear() # на случай, если это поле уже заполнено, очистим его\n",
    "un.send_keys(login)\n",
    "\n",
    "pw = form.find_element_by_name('password')\n",
    "pw.send_keys(password)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь пошлем данные браузеру командой ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "form.submit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Опять проверим, что теперь страница персонифицирована и в ней есть наше имя. Здесь `browser.page_source` — это HTML-код текущей страницы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Okay, you are logged in!\n"
     ]
    }
   ],
   "source": [
    "if name in browser.page_source:\n",
    "    print(\"Okay, you are logged in!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заметим, что мы можем управлять браузером, не только с помощью Python, но и вручную. Зайдите например, в «Мои посылки» вручную. Теперь из текущей страницы нужно извлечь информацию о посылках. Можно было бы использовать встроенные возможности Selenium по поиску HTML-элементов, но мы для простоты воспользуемся *Beautiful Soup*, передав ему `browser.page_source`. \n",
    "\n",
    "> Заметим, что `browser.page_source` — это не тот HTML-код, который был передан сервером, а тот, который мы построили на стороне клиента, в том числе, с помощью JavaScript. То есть это именно то, что нам нужно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/site-packages/bs4/__init__.py:166: UserWarning: No parser was explicitly specified, so I'm using the best available HTML parser for this system (\"lxml\"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.\n",
      "\n",
      "To get rid of this warning, change this:\n",
      "\n",
      " BeautifulSoup([your markup])\n",
      "\n",
      "to this:\n",
      "\n",
      " BeautifulSoup([your markup], \"lxml\")\n",
      "\n",
      "  markup_type=markup_type))\n"
     ]
    }
   ],
   "source": [
    "from bs4 import BeautifulSoup\n",
    "bs = BeautifulSoup(browser.page_source)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью просмотра кода элемента в браузере мы можем узнать, что интересующая нас информация находится в теге `<table>` внутри тега `<div>` с `id='Searchresult'`. Извлечем её из `bs`. При этом результат `bs('div', id = 'Searchresult')` — это список (даже если результат только один). Поэтому нам надо взять первый элемент этого списка. Потом внутри `div` мы точно так же ищем `table`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "div = bs('div', id='Searchresult')[0]\n",
    "# Можно было бы также использовать div = bs.find('div', id='Searchresult')\n",
    "\n",
    "table = div('table')[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Напечатаем ячейки в первых строках этой таблицы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<td>ID</td>\n",
      "<td>Участник</td>\n",
      "<td>Задача</td>\n",
      "<td>Дата</td>\n",
      "<td>Язык</td>\n",
      "<td>Статус</td>\n",
      "<td>Пройдено тестов</td>\n",
      "<td>Баллы</td>\n",
      "<td>Подробнее</td>\n",
      "---- Next cell ----\n",
      "<td>1758-36031</td>\n",
      "<td><a href=\"/moodle/user/view.php?id=182842\">Илья Щуров</a></td>\n",
      "<td><a href=\"/moodle/mod/statements/view3.php?chapterid=3451&amp;run_id=1758r36031\">3451. Корень степени 10.</a></td>\n",
      "<td>2016-01-08 23:32:13</td>\n",
      "<td>Python 3.3</td>\n",
      "<td> <div aria-active-descendant=\"sbo691610707\" aria-has-popup=\"true\" aria-labelledby=\"\" aria-owns=\"sbdd586279523\" class=\"sb selectbox round_sb\" id=\"sb592207805\" role=\"listbox\" style=\"width: 335px;\"><div class=\"display round_sb\" id=\"sbd91532714\"><div class=\"text\">Частичное решение</div><div class=\"arrow_btn\"><span class=\"arrow\"></span></div></div><ul aria-hidden=\"true\" class=\"selectbox items round_sb\" id=\"sbdd586279523\" role=\"menu\" style=\"max-height: 487.983px; position: absolute; visibility: visible; width: 334px; display: none; left: 339.1px; top: 206.017px;\"><li aria-disabled=\"true\" class=\"disabled first\" id=\"sbo84723798\" role=\"option\"><div class=\"item\"><div class=\"text\">---</div></div></li><li aria-disabled=\"\" id=\"sbo219628856\" role=\"option\"><div class=\"item\"><div class=\"text\">OK</div></div></li><li aria-disabled=\"\" id=\"sbo646283843\" role=\"option\"><div class=\"item\"><div class=\"text\">Перетестировать</div></div></li><li aria-disabled=\"\" id=\"sbo613943632\" role=\"option\"><div class=\"item\"><div class=\"text\">Зачтено/Принято</div></div></li><li aria-disabled=\"\" id=\"sbo820750394\" role=\"option\"><div class=\"item\"><div class=\"text\">Ошибка оформления кода</div></div></li><li aria-disabled=\"\" id=\"sbo82486357\" role=\"option\"><div class=\"item\"><div class=\"text\">Проигнорировано</div></div></li><li aria-disabled=\"\" id=\"sbo833915987\" role=\"option\"><div class=\"item\"><div class=\"text\">Ошибка компиляции</div></div></li><li aria-disabled=\"\" id=\"sbo308298062\" role=\"option\"><div class=\"item\"><div class=\"text\">Дисквалифицировано</div></div></li><li aria-disabled=\"\" class=\"selected\" id=\"sbo691610707\" role=\"option\"><div class=\"item\"><div class=\"text\">Частичное решение</div></div></li><li aria-disabled=\"\" id=\"sbo81841931\" role=\"option\"><div class=\"item\"><div class=\"text\">Ожидает проверки</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo154124644\" role=\"option\"><div class=\"item\"><div class=\"text\">Ошибка во время выполнения программы</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo338287886\" role=\"option\"><div class=\"item\"><div class=\"text\">Превышено максимальное время работы</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo222561433\" role=\"option\"><div class=\"item\"><div class=\"text\">Неправильный формат вывода</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo209389642\" role=\"option\"><div class=\"item\"><div class=\"text\">Неправильный ответ</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo983545951\" role=\"option\"><div class=\"item\"><div class=\"text\">Ошибка проверки,обратитесь к администраторам</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo308282719\" role=\"option\"><div class=\"item\"><div class=\"text\">Превышение лимита памяти</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo155768573\" role=\"option\"><div class=\"item\"><div class=\"text\">Security error</div></div></li><li aria-disabled=\"true\" class=\"disabled\" id=\"sbo127414586\" role=\"option\"><div class=\"item\"><div class=\"text\">Тестирование...</div></div></li><li aria-disabled=\"true\" class=\"disabled last\" id=\"sbo603528756\" role=\"option\"><div class=\"item\"><div class=\"text\">Компилирование...</div></div></li></ul></div><select class=\"round_sb has_sb\" name=\"56901da4b1223\" onchange=\"rejudgeRun(1758, 36031, this)\" style=\"display: block;\">\n",
      "<option disabled=\"disabled\" value=\"0\">---</option>\n",
      "<option value=\"r0\">OK</option>\n",
      "<option value=\"r99\">Перетестировать</option>\n",
      "<option value=\"r8\">Зачтено/Принято</option>\n",
      "<option value=\"r14\">Ошибка оформления кода</option>\n",
      "<option value=\"r9\">Проигнорировано</option>\n",
      "<option value=\"r1\">Ошибка компиляции</option>\n",
      "<option value=\"r10\">Дисквалифицировано</option>\n",
      "<option selected=\"selected\" value=\"r7\">Частичное решение</option>\n",
      "<option value=\"r11\">Ожидает проверки</option>\n",
      "<option disabled=\"disabled\" value=\"r2\">Ошибка во время выполнения программы</option>\n",
      "<option disabled=\"disabled\" value=\"r3\">Превышено максимальное время работы</option>\n",
      "<option disabled=\"disabled\" value=\"r4\">Неправильный формат вывода</option>\n",
      "<option disabled=\"disabled\" value=\"r5\">Неправильный ответ</option>\n",
      "<option disabled=\"disabled\" value=\"r6\">Ошибка проверки,обратитесь к администраторам</option>\n",
      "<option disabled=\"disabled\" value=\"r12\">Превышение лимита памяти</option>\n",
      "<option disabled=\"disabled\" value=\"r13\">Security error</option>\n",
      "<option disabled=\"disabled\" value=\"r96\">Тестирование...</option>\n",
      "<option disabled=\"disabled\" value=\"r98\">Компилирование...</option>\n",
      "</select>\n",
      "</td>\n",
      "<td>0</td>\n",
      "<td>0</td>\n",
      "<td><a href=\"/moodle/ajax/ajax_file.php?objectName=source&amp;contest_id=1758&amp;run_id=36031\" onclick=\"loadSourceWindow(1758, 36031, '1');return false;\">Подробнее</a></td>\n",
      "---- Next cell ----\n"
     ]
    }
   ],
   "source": [
    "for row in table('tr')[:2]:\n",
    "    # я печатаю только первые две строки\n",
    "    for cell in row('td'):\n",
    "        print(cell)\n",
    "    print(\"---- Next cell ----\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выглядит страшновато, но вообще-то видно, что вся интересующая нас информация как раз и находится в ячейках этой таблицы. Если нас интересует какая-то конкретная колонка, например дата и время отправки посылки, то её значения можно получить вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Дата\n",
      "2016-01-08 23:32:13\n",
      "2016-01-08 23:32:01\n",
      "2016-01-08 23:31:48\n",
      "2016-01-08 23:31:25\n",
      "2015-10-06 02:39:28\n",
      "2015-10-06 02:37:48\n",
      "2015-10-06 02:36:33\n",
      "2015-09-29 14:33:09\n",
      "2015-09-22 14:39:18\n",
      "2015-09-08 14:18:28\n"
     ]
    }
   ],
   "source": [
    "for row in table('tr'):\n",
    "    cells = row('td')\n",
    "    print(cells[3].string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если мы хотим выписать все элементы, то нам надо будет перейти на следующую страницу листинга. В браузере мы видим стрелочу `>`, ведущую к следующей странице результатов. Найдем элемент соответствующий этой стрелке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = browser.find_element_by_link_text('>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "К счастью, на странице это единственный элемент с таким текстом. Чтобы кликнуть по нему, сделаем следующее"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a.click()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видим, что загрузилась следующая страница, её можно обработать таким же образом, что и раньше.\n",
    "\n",
    "Это можно повторять в цикле, и таким образом обработать все записи. Нужно только учитывать то, что Python не будет ждать загрузки страницы в браузере, прежде, чем выполнять следующие команды, поэтому, делая `browser.page_source`, мы рискуем загрузить старую страницу. Чтобы решить эту проблему, сделаем в Python искусственную паузу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time\n",
    "time.sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта команда сделает паузу на любое время в секундах (здесь на 1 секунду)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Отметим, что в `Selenium` есть команд «назад»…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "browser.back()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "…команда «вперёд»…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "browser.forward()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "…и «обновить»:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "browser.refresh()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В общем, это полноценный браузер на дистанционном управлении. Теперь вы можете автоматизировать всё на свете!"
   ]
  }
 ],
 "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}