2_Page_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide_input": true,
    "init_cell": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.execute_cells_below()"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.execute_cells_below()"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<script>\n",
       "var update_input_visibility = function () {\n",
       "    Jupyter.notebook.get_cells().forEach(function(cell) {\n",
       "        if (cell.metadata.hide_input) {\n",
       "            cell.element.find(\"div.input\").hide();\n",
       "        }\n",
       "    })\n",
       "};\n",
       "update_input_visibility();\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<script>\n",
       "document.getElementById('notebook').scrollIntoView();\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import json\n",
    "import copy\n",
    "from IPython.display import display, Javascript, HTML, clear_output\n",
    "from ipywidgets import widgets, Output, interact, fixed, Layout\n",
    "from ipywidgets.widgets import Dropdown, interactive_output, VBox, HBox, interactive, FloatText\n",
    "from datetime import datetime, timedelta\n",
    "from urllib.parse import quote_plus\n",
    "from utils.notebooks import get_date_slider_from_datetime, get_next_notebook, get_previous_notebook\n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cells_below()'))\n",
    "\n",
    "re_hide = \"\"\"\n",
    "<script>\n",
    "var update_input_visibility = function () {\n",
    "    Jupyter.notebook.get_cells().forEach(function(cell) {\n",
    "        if (cell.metadata.hide_input) {\n",
    "            cell.element.find(\"div.input\").hide();\n",
    "        }\n",
    "    })\n",
    "};\n",
    "update_input_visibility();\n",
    "</script>\n",
    "\"\"\"\n",
    "display(HTML(re_hide))\n",
    "\n",
    "\n",
    "scroll_to_top = \"\"\"\n",
    "<script>\n",
    "document.getElementById('notebook').scrollIntoView();\n",
    "</script>\n",
    "\"\"\"\n",
    "display(HTML(scroll_to_top))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "summary{\n",
       "    display:list-item;\n",
       "}\n",
       "\n",
       ".widget-radio-box{\n",
       "    flex-direction: row;\n",
       "}\n",
       "\n",
       ".widget-radio-box input{\n",
       "    margin:0 6px 0 5px\n",
       "}\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    "summary{\n",
    "    display:list-item;\n",
    "}\n",
    "\n",
    ".widget-radio-box{\n",
    "    flex-direction: row;\n",
    "}\n",
    "\n",
    ".widget-radio-box input{\n",
    "    margin:0 6px 0 5px\n",
    "}\n",
    "</style>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "## Some Extensions ##\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%store -r the_page\n",
    "\n",
    "if 'the_page' not in locals():\n",
    "    import pickle\n",
    "    print(\"Loading default data...\")\n",
    "    the_page = pickle.load(open(\"data/the_page.p\",'rb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": true,
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "### <span style=\"color:green\"> Modules Imported </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "## Modules Imported ##\n",
    "\n",
    "# Display\n",
    "from IPython.display import display, Markdown as md, clear_output\n",
    "from datetime import date\n",
    "import urllib\n",
    "\n",
    "# APIs\n",
    "from wikiwho_wrapper import WikiWho\n",
    "from external.wikipedia import WikipediaDV, WikipediaAPI\n",
    "from external.wikimedia import WikiMediaDV, WikiMediaAPI\n",
    "from external.xtools import XtoolsAPI, XtoolsDV\n",
    "\n",
    "# Data Processing\n",
    "import pickle\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Visualization tools\n",
    "import qgrid\n",
    "import matplotlib.pyplot as plt\n",
    "import plotly\n",
    "from plotly.subplots import make_subplots\n",
    "\n",
    "# Page views timeline\n",
    "from visualization.views_listener import ViewsListener\n",
    "\n",
    "# Change actions timeline\n",
    "from visualization.actions_listener import ActionsListener\n",
    "\n",
    "# Actions per editor visualization\n",
    "from visualization.editors_listener import EditorsListener\n",
    "from visualization.editors_listener import RankedEditorsListener\n",
    "\n",
    "# Conflicts visualization\n",
    "from visualization.conflicts_listener import ConflictsListener, ConflictsActionListener, ConflictsEditorListener\n",
    "from visualization.calculator_listener import ConflictCalculatorListener\n",
    "\n",
    "# Word cloud visualization\n",
    "from visualization.wordcloud_listener import WCListener, WCActionsListener\n",
    "from visualization.wordclouder import WordClouder\n",
    "\n",
    "# Tokens per revision visualization\n",
    "from visualization.tokens_listener import TokensListener, TokensOwnedListener\n",
    "\n",
    "# Wikipedia talk pages visualization\n",
    "from visualization.talks_listener import TalksListener\n",
    "from visualization.topics_listener import TopicsListener\n",
    "\n",
    "# Tokens ownership visualization\n",
    "from visualization.owned_listener import OwnedListener\n",
    "\n",
    "# Metrics management\n",
    "from metrics.conflict import ConflictManager\n",
    "from metrics.token import TokensManager\n",
    "\n",
    "# For language selection\n",
    "from utils.lngselection import abbreviation, lng_listener"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can continue with the article selected in the previous notebook (skip the search button below) or change it  (e.g., if you would like to compare two or more articles):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8f4c299c96f146c4b46e68f695d14b99",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dd4c89fdc88a4291a79e0876cadbb3ef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# the method that listens to the click event\n",
    "def on_button_clicked(b):\n",
    "    global the_page, the_talk_page\n",
    "    \n",
    "    # use the out widget so the output is overwritten when two or more\n",
    "    # searches are performed\n",
    "    with out0:\n",
    "        try:\n",
    "            # query wikipedia\n",
    "            wikipedia_dv = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "            search_result = wikipedia_dv.search_page(searchTerm.value)\n",
    "            the_page = wikipedia_dv.get_page(search_result)\n",
    "            the_talk_page = wikipedia_dv.get_page(\"Talk:\"+search_result)\n",
    "            %store the_page\n",
    "            clear_output()\n",
    "            display(md(f\"The page that was found: **{the_page['title']}**\"))\n",
    "            display(md(f\"Page id: **{the_page['page_id']}**\"))\n",
    "\n",
    "        except:\n",
    "            clear_output()\n",
    "            display(md(f'The page title *\"{searchTerm.value}\"* was not found'))\n",
    "\n",
    "# Load the selection from NB1\n",
    "with open('utils/language.json', 'r') as file:\n",
    "    json_selection = json.load(file)\n",
    "    lng_nb1 = json_selection['lng']\n",
    "    title_nb1 = json_selection['search_term']\n",
    "\n",
    "# Language selection.\n",
    "languageSelection = Dropdown(options=['English', 'Deutsch', 'Español', 'Türkçe', 'Euskara'], value=lng_nb1, description='Language:')            \n",
    "\n",
    "# by default display the last search\n",
    "try:\n",
    "    searchTerm = widgets.Text(the_page['title'], description='Page title:')\n",
    "except:\n",
    "    searchTerm = widgets.Text(title_nb1, description='Page title:')\n",
    "\n",
    "out_main = Output()\n",
    "display(out_main)\n",
    "with out_main:\n",
    "    second_select = widgets.interactive(lng_listener, lng=languageSelection, search_term=searchTerm)\n",
    "    display(second_select.children[0])\n",
    "    display(second_select.children[1])\n",
    "\n",
    "    # create and display the button    \n",
    "    button = widgets.Button(description=\"Search\")\n",
    "    display(button)\n",
    "\n",
    "# the output widget is used to remove the output after the search field\n",
    "out0 = Output()\n",
    "display(out0)\n",
    "\n",
    "# set the event\n",
    "button.on_click(on_button_clicked)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_button_clicked(button)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Click on \"Refresh All Variables\" to reload all following cells with the selected article. (may take a some time)** \n",
    "\n",
    "Alternatively, reload each module individually via their respective buttons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <script>\n",
       "                code_show = false;\n",
       "                function restart_run_all(){\n",
       "                    IPython.notebook.kernel.restart();\n",
       "                    setTimeout(function(){\n",
       "                        IPython.notebook.execute_all_cells();\n",
       "                    })\n",
       "                }\n",
       "            </script>\n",
       "            <button onclick=\"restart_run_all()\">Refresh All Variables</button>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def restart_and_run():\n",
    "    display(HTML(\n",
    "        '''\n",
    "            <script>\n",
    "                code_show = false;\n",
    "                function restart_run_all(){\n",
    "                    IPython.notebook.kernel.restart();\n",
    "                    setTimeout(function(){\n",
    "                        IPython.notebook.execute_all_cells();\n",
    "                    })\n",
    "                }\n",
    "            </script>\n",
    "            <button onclick=\"restart_run_all()\">Refresh All Variables</button>\n",
    "        '''\n",
    "    ))\n",
    "restart_and_run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "#### Troubleshooting:\n",
    "\n",
    "- Allow some time for the notebook to run fully before interacting with the interface controls. For articles with a long revision history, this could take minutes and the interaction with the controls will be slow.\n",
    "- Very large articles (\"Donald Trump\", \"World War 2\") may lead to memory overload, depending on which Binder platform you are using. You could get more memory by shutting down some previous running notebooks.\n",
    "- **All cells should run automatically** when you open the notebook and you should not see any code. If that is not the case, please just reload the tab in your browser. \n",
    "- After chosing a new article, please rerun the cells/modules you want to use. \n",
    "- You should not see any code when you run it for the first time. If so, please let us know by posting an issue in our Github repository: https://github.com/gesiscss/IWAAN/issues."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "---\n",
    "\n",
    "# A. Change actions and their impact\n",
    "\n",
    "**The dynamics of individual changes** made to every word (and each special character) in the article are extracted and collected by the WikiWho service, and we access them through the [WikiWho API](https://www.wikiwho.net/en/api/v1.0.0-beta/). \n",
    "\n",
    "Below, you will find several metrics for such change dynamics such as unsucessful changes (i.e. changes reverted by other editors) and conflict (defined below). \n",
    "\n",
    "<br>\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">More information about WikiWho's method</summary>\n",
    "\n",
    "\n",
    "The [WikiWho API](https://www.wikiwho.net/en/api/v1.0.0-beta/) accurately tracks the changes to every token (words or special characters) for live Wikipedia articles. It distinguishes every token in the document even when the string appears several times. For example, \"and\" at the beginning of an article is a different token than \"and\" at the end of the article. See also [this figure](https://www.wikiwho.net/#technical_details).\n",
    "\n",
    "That means that *not only edits* (== whole revisions) are counted, which can contain changes of many different tokens, but *every single action to every single token* is recorded. \n",
    " <br>   \n",
    "   The two most basic actions that can perfomed per token are **insertions** and **deletions**. \n",
    "    (Side note: A character change in a word, e.g. \"dog\" -> \"dogs\", is modeled as deletion of \"dog\" and the insertion of \"dogs\", two separate tokens.)\n",
    " <br>   \n",
    "    An **insertion** is also considered a **re-insertion** if the insertion has occured before; the only insertion of a token that is not a re-insertion is the first one (original addition of the token, or **add**).\n",
    "\n",
    "Formally, the token history can be represented by a time-ordered sequence of actions \n",
    "*(a<sub>0</sub>, ..., a<sub>n</sub>)*; note that *a<sub>0+2i</sub>* is always an insertion and \n",
    "*a<sub>1+2i</sub>* is always a deletion for i ∈ ℕ.\n",
    "</details> \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.1 Actions over time - When did certain change actions happen?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "Let's start with the simplest form of information that we can directly access from the WikiWho API, i.e. the actions that have been perfomed on the tokens of the articles. \n",
    "\n",
    "The following graph displays the number of actions (y-axis) that occured through time (x-axis). You can interact with this graph by:\n",
    "\n",
    "1. choosing the *date range* and *granularity* (yearly, monthly) of the timeline (X-axis), and \n",
    "2. selecting any of the *change action types* in the black, red, blue and green traces. \n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Explanation of the change action types</summary>\n",
    "\n",
    "   \n",
    "- **adds**: number of first-time insertions / additions\n",
    "- **adds_surv_48h**: number of adds that survived at least 48 hours (after 48h, the risk of being removed is negligible on avg.)\n",
    "- **adds_stopword_count**:  number of insertions that were only [stop words](https://github.com/gesiscss/wikiwho_demo_new/blob/master/data/stopword_list.txt)\n",
    "<br>\n",
    "\n",
    "- **dels**: number of deletions\n",
    "- **dels_surv_48h**: number of deletions that were not resinserted in the next 48 hours \n",
    "- **dels_stopword_count**: number of deletions that were only [stop words](https://github.com/gesiscss/wikiwho_demo_new/blob/master/data/stopword_list.txt)\n",
    "<br>\n",
    "\n",
    "- **reins**: number of reinsertions\n",
    "- **reins_surv_48h**: number of reinsertions that survived at least 48 hours\n",
    "- **reins_stopword_count**: number of reinsertions that were only [stop words](https://github.com/gesiscss/wikiwho_demo_new/blob/master/data/stopword_list.txt)\n",
    "</details>\n",
    "<br>\n",
    "\n",
    "\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Example</summary>\n",
    "\n",
    "For instance, if you see 10 \"adds\" in a month, but only 4 \"adds_surv_48h\", then 10 completely new tokens/words have been added to the article, but only 4 of them stayed in the article for more than 2 days, which usually means the other 6 are gone for good. If \"dels\" are performed and don't survive, that means that these deletions have been undone, i.e., the deleted tokens have been reinserted (you should see at least the same amount of reinsertions happen). In other words, these are measurements of the longevity and stability of edit actions done to the article.\n",
    "</details>\n",
    "<br>\n",
    "\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">How is <i>conflict</i> measured?</summary>\n",
    "\n",
    "Our measurement of ***conflict*** for single tokens is taken from [Flöck et al.](https://arxiv.org/abs/1703.08244):\n",
    "\n",
    "\n",
    "* (1)  The main idea is to count how often a token (after being created (added) the first time) has been deleted, re-inserted, re-deleted, re-inserted, and so on; which would often happen in case two editors disagree on the token's justification to be in the text. \n",
    "* (2) Only the **re-**deletions and **re-**insertions are counted, since up to the first delete it could be a simple correction that didn't trigger a reponse - this wouldn't indicate conflict. \n",
    "* (3) The **\"re-\"** actions are only counted if they alternate between different editors and don't come from the same editor twice or more in a row - as the latter would simply indicate self-corrections. \n",
    "* (4) In a last step, each re-insertion/re-deletion interaction gets a higher weight the faster it occurs (see [Flöck et el.](https://arxiv.org/abs/1703.08244) for the exact formula).\n",
    "\n",
    "The total conflict of a page is the sum of all the conflict scores of all actions with conflict (or conflict actions).\n",
    "\n",
    "This total conflict can be normalized (between 0 and 1) if the sum is divided by the number of actions that could have been potentially counted as conflict, i.e. a **re-**deletion or **re-**insertion (called *elegible actions*).\n",
    "\n",
    "The conflict scores in all notebooks are calculated based on the tokens excluding stopwords.\n",
    "</details>\n",
    "<br>\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Vandalism detection with ORES, \"Goodfaith\" and \"Damage\" scores</summary>\n",
    "\n",
    "Typically, a lot of the adds, deletes and reinserts are generated by vandalism and vandalism fighting. This obscures the \"real\" work on the article in the graph below, particularly as these frequently involve large chunks of text being deleted and reinserted. We thus filter out such actions that come from (i) revisions that are probably vandalism **and** (ii) such that repair them. Otherwise, say,  500 tokens reinserted after a not-shown 500 vandalistic deletes would look pretty odd. \n",
    "    <br><br>\n",
    "        This happens via filtering the revisions based on thresholded values for \"Goodfaith\" (well-intened edit yes/no) and \"Damage\" (actual quality decrease for the article) scores retrieved live from the [ORES API](https://ores.wikimedia.org/). We found that the threshold-combination of lower than 0.6 damage and higher than 0.6 goodfaith scores work quite well for most articles, but you are encouraged to check for yourself if the vandalism filtering works as intendend or if you have to alter these parameters. \n",
    "    <br><br>\n",
    "    For one or a range of vandalistic revisions, we consider the immediately subsequent one (with non-vandalistic scores) to be the \"fixer\" and filter it out as well. If you set the thresholds to zero, the filters are deactivated. \n",
    "</details>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3a70524c3a334a0cb9da3b09e91869a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Load Actions', layout=Layout(width='160px'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "92d663300b6d4dd8991022b5f0aa1eca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import operator\n",
    "from external.ores import ORESAPI, ORESDV\n",
    "\n",
    "def get_ores_scores(rev_list):\n",
    "    # Get data from ORES\n",
    "    oapi = ORESAPI()\n",
    "    ores = ORESDV(oapi)\n",
    "    max_requests = 50\n",
    "    rev_list = list(map(str, rev_list))\n",
    "    res = ores.get_goodfaith_damage(rev_list[0:max_requests])\n",
    "    i = 1\n",
    "    while len(res) < len(rev_list): \n",
    "        #print(len(res), len(rev_list))\n",
    "        tmp = ores.get_goodfaith_damage(rev_list[max_requests*i:max_requests*i+max_requests])\n",
    "        res = res.append(tmp)\n",
    "        i = i+1\n",
    "        \n",
    "    return res\n",
    "\n",
    "# create and display the button\n",
    "button2 = widgets.Button(description=\"Load Actions\", layout=Layout(width='160px'))\n",
    "\n",
    "display(button2)\n",
    "\n",
    "def on_click_details(b):\n",
    "    global agg_actions\n",
    "    global editors\n",
    "    global action_types\n",
    "    global sources    \n",
    "    global actions_inc_stop\n",
    "    global revisions\n",
    "    global con_manager_all\n",
    "    global ores_scores\n",
    "    global listener\n",
    "    global all_content\n",
    "    global wikiwho\n",
    "    global total_actions\n",
    "    global token_sources\n",
    "    with out4:\n",
    "        clear_output()\n",
    "       \n",
    "        # Preparetory works\n",
    "        wikiwho = WikiWho(lng=abbreviation(languageSelection.value))\n",
    "        display(md(\"Downloading all_content from the WikiWhoApi...\"))\n",
    "        all_content = wikiwho.dv.all_content(the_page['page_id'])\n",
    "        display(md(\"Downloading revisions from the WikiWhoApi...\"))\n",
    "        revisions = wikiwho.dv.rev_ids_of_article(the_page['page_id'])\n",
    "        clear_output()\n",
    "        \n",
    "        con_manager_all = ConflictManager(all_content, \n",
    "                                           revisions.copy(), \n",
    "                                           lng=abbreviation(languageSelection.value), \n",
    "                                           include_stopwords=True)\n",
    "\n",
    "        con_manager_all.calculate()\n",
    "        clear_output()\n",
    "        \n",
    "        sources = con_manager_all.source\n",
    "        sources[\"wiki_dv\"] = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "        \n",
    "        listener = ActionsListener(sources=sources, lng=abbreviation(languageSelection.value))\n",
    "        listener.get_main()\n",
    "        \n",
    "        # Filter spam with ORES\n",
    "        tmp = revisions['rev_id'].to_list()\n",
    "        ores_scores = get_ores_scores(tmp)\n",
    "        listener.ores_scores= ores_scores\n",
    "        \n",
    "        #not_spam = filter_vandalism_ores(ores_scores, goodfaith_cmp='>', goodfaith_threshold=0.9, damaging_cmp='<=', damaging_threshold=0.09)\n",
    "        #listener.df = listener.df[~listener.df['rev_id'].isin(not_spam)]\n",
    "        \n",
    "        clear_output()\n",
    "        agg_actions = listener.df.copy()\n",
    "        actions_inc_stop = listener.tokens_group_all.copy()\n",
    "        editors = listener.editors.copy()\n",
    "       \n",
    "        # Merge the names of the editors to the aggregate actions dataframe\n",
    "        display(md(f\"***Page: {the_page['title']} ({abbreviation(languageSelection.value).upper()}) with {agg_actions['revisions'].sum()} revisions***\"))\n",
    "\n",
    "        # Visualization\n",
    "        action_types = (agg_actions.columns[5:14]).values.tolist()\n",
    "        datepicker_from = widgets.DatePicker(description='Date starts', value=agg_actions['rev_time'].iloc[0],\n",
    "                                             style={'description_width': '40%'}, layout=Layout(width=\"29%\"))\n",
    "        datepicker_to = widgets.DatePicker(description='Date ends', value=agg_actions['rev_time'].iloc[-1],\n",
    "                                           style={'description_width': '43%'}, layout=Layout(width=\"31%\"))\n",
    "        editor_all = fixed('All')\n",
    "        frequency = Dropdown(options=['Yearly', 'Monthly', 'Weekly', 'Daily'], value='Monthly', description=\"Granularity\",\n",
    "                             style={'description_width': '43%'}, layout=Layout(width=\"32%\"))\n",
    "        black_actions = Dropdown(options=action_types, value='adds', description=\"All Actions(black)\", style={'description_width': '40%'})\n",
    "        red_actions = Dropdown(options= ['None'] + action_types, value=\"adds_surv_48h\", description=\"All Actions(red)\", style={'description_width': '40%'})\n",
    "        green = Dropdown(options= ['None'] + action_types, value='None', description=\"All Actions(green)\", style={'description_width': '40%'})\n",
    "        blue = Dropdown(options= ['None'] + action_types, value='None', description=\"All Actions(blue)\", style={'description_width': '40%'})\n",
    "        \n",
    "        metrics = ['Absolute Conflict Score', 'Norm. Conflict Score']\n",
    "        black_conflict = Dropdown(options=metrics, value='Absolute Conflict Score', description=\"Conflict(black)\", style={'description_width': '40%'})\n",
    "        red_conflict = Dropdown(options= ['None'] + metrics, value='Norm. Conflict Score', description=\"Conflict(red)\", style={'description_width': '40%'})\n",
    "       \n",
    "        damage_t = widgets.FloatText(description='Damage Threshold', style={'description_width': '40%'}, value=0.6)\n",
    "        goodwill_t = widgets.FloatText(description='Goodfaith Threshold', style={'description_width': '40%'}, value=0.6)\n",
    "        damage_c =  Dropdown(options=['<','>','='], value='<', description=\"Damage Comparator\", style={'description_width': '40%'})\n",
    "        goodwill_c =  Dropdown(options=['<','>','='], value='>', description=\"Goodfaith Comparator\", style={'description_width': '40%'})\n",
    "        \n",
    "        test_fig = make_subplots(rows=2, cols=1, start_cell=\"bottom-left\", shared_xaxes=True, vertical_spacing=0.05)\n",
    "        \n",
    "        # All actions\n",
    "        actions_out = interactive_output(listener.listen, \n",
    "            {\"_range1\": datepicker_from,\n",
    "            \"_range2\": datepicker_to,\n",
    "            \"editor\": fixed('All'),\n",
    "            \"granularity\": frequency,\n",
    "            \"black\": black_actions,\n",
    "            \"red\": red_actions,\n",
    "            \"green\": green,\n",
    "            \"blue\": blue,\n",
    "            \"black_conflict\": black_conflict,\n",
    "            \"red_conflict\": red_conflict,\n",
    "            \"damage_t\": damage_t,\n",
    "            \"goodwill_t\": goodwill_t,\n",
    "            \"damage_c\": damage_c,\n",
    "            \"goodwill_c\": goodwill_c})\n",
    "        display(HBox([datepicker_from, datepicker_to, frequency]))\n",
    "        display(HBox([black_actions, red_actions, green, blue, black_conflict, red_conflict],\n",
    "                    layout=Layout(flex_flow='wrap')))\n",
    "        display(HBox([damage_c, damage_t]))\n",
    "        display(HBox([goodwill_c, goodwill_t]))\n",
    "        display(actions_out)\n",
    "        \n",
    "        red_actions.value = \"dels\"\n",
    "        token_sources = sources.copy()\n",
    "        total_actions = agg_actions.copy()\n",
    "    \n",
    "out4 = Output()\n",
    "display(out4)\n",
    "\n",
    "# set the event\n",
    "button2.on_click(on_click_details)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_details(button2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false,
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Load Actions' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "## IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### --------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Load Actions' BUTTON ###\n",
    "### --------------------------------------------------------------------------- ###\n",
    "\n",
    "## Create a WikiWho instance, which is an API; and use ConflictManager to get         ##\n",
    "## actions for given page id; more details see:                                       ##\n",
    "## https://github.com/gesiscss/wikiwho_wrapper/blob/master/wikiwho_wrapper/api.py     ##\n",
    "## https://github.com/gesiscss/wikiwho_wrapper/blob/master/wikiwho_wrapper/wikiwho.py ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/metrics/conflict.py       ##\n",
    "# wikiwho_api = WikiWho(lng=abbreviation(languageSelection.value))\n",
    "# print(\"Downloading all_content from the WikiWhoApi...\")\n",
    "# all_content = wikiwho_api.dv.all_content(the_page['page_id'])\n",
    "# print(\"Downloading revisions from the WikiWhoApi...\")\n",
    "# all_revisions = wikiwho_api.dv.rev_ids_of_article(the_page['page_id'])\n",
    "# clear_output()\n",
    "\n",
    "# conflict_manager = ConflictManager(all_content.copy(),\n",
    "#                                all_revisions.copy(), \n",
    "#                                lng=abbreviation(languageSelection.value), \n",
    "#                                include_stopwords=True)\n",
    "\n",
    "# conflict_manager.calculate()\n",
    "# clear_output()\n",
    "\n",
    "# Store the original data into variable \"token_sources\", it includes\n",
    "# \"tokens_all\" / \"tokens\" (all actions of an article, including/excluding stopwords)\n",
    "# \"elegibles_all\" / \"elegibles\" (elegible actions of an article, including/excluding stopwords)\n",
    "# \"conflicts_all\" / \"conflicts\" (conflict actions of an article, including/excluding stopwords)\n",
    "# \"wiki_dv\" (a WikipediaDV instance for retrieving editors' names given their IDs)\n",
    "# token_sources = conflict_manager.source\n",
    "# token_sources[\"wiki_dv\"] = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "token_sources = sources.copy()\n",
    "all_revisions = revisions.copy()\n",
    "\n",
    "## Create an ActionsListener instance to get aggregated actions. More details see:            ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/actions_listener.py ##\n",
    "actions_listener = ActionsListener(sources=token_sources, lng=abbreviation(languageSelection.value))\n",
    "actions_listener.get_main()\n",
    "clear_output()\n",
    "\n",
    "# Aggregation data for actions.\n",
    "total_actions = agg_actions\n",
    "\n",
    "# adds/dels/reins actions (including stopwords)\n",
    "actions_inc = actions_listener.tokens_group_all.copy()\n",
    "\n",
    "# Editors' names.\n",
    "grabbed_names = actions_listener.editors.copy()\n",
    "\n",
    "# Filter spam with ORES\n",
    "tmp = revisions['rev_id'].to_list()\n",
    "ores_scores = get_ores_scores(tmp)\n",
    "actions_listener.ores_scores= ores_scores\n",
    "        \n",
    "## Visualization, core visual code lies in ActionsListener, then the interact function     ##\n",
    "## makes it interactive, mode details see:                                                 ##\n",
    "## https://github.com/gesiscss/wikiwho_demo/blob/master/visualization/actions_listener.py  ##\n",
    "\n",
    "# This is the page you used\n",
    "print('The page that is being used:', the_page['title'], f'({abbreviation(languageSelection.value).upper()})')\n",
    "\n",
    "# Which types do those actions have?\n",
    "actions_types = (total_actions.columns[5:14]).values.tolist()\n",
    "\n",
    "# Visualization: try yourself by coding!\n",
    "begin_date = date(2001, 7, 16)\n",
    "end_date = date(2020, 12, 5)\n",
    "editor_name = 'All'\n",
    "frequency = 'Monthly' # \"Yearly\", \"Monthly\", \"Weekly\", \"Daily\"\n",
    "black_line = 'adds' # Choose one from 'actions_types'. Note that 'black_line doesn't have 'None' option but others have.\n",
    "red_line = 'dels'\n",
    "blue_line = 'None'\n",
    "green_line = 'None'\n",
    "black_conflict = \"Absolute Conflict Score\"  # 'Conflict Score', 'Absolute Conflict Score', 'Total Elegible Actions'\n",
    "red_conflict = \"None\"\n",
    "damage_t = 0.6\n",
    "goodwill_t = 0.6\n",
    "damage_c = \"<\"\n",
    "goodwill_c = \">\"\n",
    "\n",
    "actions_listener.listen(\n",
    "    _range1 = begin_date,\n",
    "    _range2 = end_date,\n",
    "    editor = editor_name,\n",
    "    granularity = frequency,\n",
    "    black = black_line,\n",
    "    red = red_line,\n",
    "    blue = blue_line,\n",
    "    green = green_line,\n",
    "    black_conflict = black_conflict,\n",
    "    red_conflict = red_conflict,\n",
    "    damage_t = damage_t,\n",
    "    goodwill_t = goodwill_t,\n",
    "    damage_c = damage_c,\n",
    "    goodwill_c = goodwill_c\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.2 Impactful editors - Who has productively contributed?\n",
    "\n",
    "The following elements present the editors who have contributed and whose changes have not been removed for 48 hours, which it is an heuristic to exclude low-quality contributions from being shown. Given time interval and granularity, the first chart ranks all editors by all their edits that have survived for 48 hours and displays top 20/10/5 editors. The second graph then shows the evolution of these actions along the time axis for each editor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b20e4872ee94de8bd33768a6fadc082",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Get Editors Rank', layout=Layout(width='160px'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c9475a1a32b9418babb69bba8b069191",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create and display the button\n",
    "button_rank = widgets.Button(description=\"Get Editors Rank\", layout=Layout(width='160px'))\n",
    "\n",
    "display(button_rank)\n",
    "\n",
    "def on_click_rank(b):\n",
    "    with out_rank:\n",
    "        clear_output()\n",
    "        display(md(f\"***Page: {the_page['title']} ({abbreviation(languageSelection.value).upper()})***\"))\n",
    "        \n",
    "        ranked_listener = RankedEditorsListener(agg_actions)\n",
    "\n",
    "        datepicker_from = widgets.DatePicker(description='Date starts', value=agg_actions['rev_time'].iloc[0], layout=Layout(width='25%'))\n",
    "        datepicker_to = widgets.DatePicker(description='Date ends', value=agg_actions['rev_time'].iloc[-1], layout=Layout(width='25%'))\n",
    "        frequency = Dropdown(description='Granularity', options=['Monthly', 'Weekly', 'Daily', 'Timestamp (Revision)'], value='Monthly')\n",
    "        top = widgets.RadioButtons(options=[5, 10, 20], value=20, description=\"Top Editors\", layout={'width': '50%'})\n",
    "\n",
    "        interact(ranked_listener.listen,\n",
    "                _range1=datepicker_from,\n",
    "                _range2=datepicker_to,\n",
    "                granularity=frequency,\n",
    "                top=top)\n",
    "        \n",
    "out_rank = Output()\n",
    "display(out_rank)\n",
    "\n",
    "# set the event\n",
    "button_rank.on_click(on_click_rank)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_rank(button_rank)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Get Editors Rank' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "scrolled": true,
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### ------------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Get Editors Info' BUTTON ###\n",
    "### ------------------------------------------------------------------------------- ###\n",
    "\n",
    "## Create an RankedEditorsListener instance, more details can be found in                     ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/editors_listener.py ##\n",
    "\n",
    "rank_listener = RankedEditorsListener(total_actions)\n",
    "\n",
    "## Visualization, core visual code lies in RankedEditorsListener, then the interact function  ##\n",
    "## makes it interactive.                                                                      ##\n",
    "\n",
    "# This is the page you used\n",
    "print('The page that is being used:', the_page['title'], f'({abbreviation(languageSelection.value).upper()})')\n",
    "\n",
    "# Visualization: parameters\n",
    "begin_date = date(2007, 3, 1)\n",
    "end_date = date(2020, 5, 1)\n",
    "frequency = 'Monthly' # \"Monthly\", \"Weekly\", \"Daily\"\n",
    "top_editors = 20 # 20, 10, 5\n",
    "\n",
    "# Visualization: chart and graph\n",
    "rank_listener.listen(_range1=begin_date,\n",
    "                    _range2=end_date,\n",
    "                    granularity=frequency,\n",
    "                    top=top_editors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.3 Token ownership - Which editors were original authors of how much text per time frame?\n",
    "\n",
    "The graph below displays the number of tokens \"owned\" by the top-15 editors for the given time period. Token ownerships are counted as original additions that have not been deleted by the end of a timeframe. The number of total tokens existing on a page can be considered as the top line of a graph. \n",
    "\n",
    "The granularity (daily, weekly or monthly) controls if the latest revision would be considered within a time window. For example, for daily period the latest revision during each day is considered. \n",
    "\n",
    "You can remove editors by clicking on their name in the legend and keep only a specific editor by double-clicking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "729371ab149f41a1ad15068feb84724e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Show token owners', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66277692c58a45828ca4550cd280f6f3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# # create and display the button\n",
    "button_a21 = widgets.Button(description=\"Show token owners\")\n",
    "display(button_a21)\n",
    "\n",
    "\n",
    "def on_click_owned_tokens(b):\n",
    "    with out21:\n",
    "        clear_output()\n",
    "        display(md(f\"***Page: {the_page['title']} ({abbreviation(languageSelection.value).upper()})***\"))\n",
    "        listener = TokensOwnedListener(agg_actions, sources, lng=abbreviation(languageSelection.value))\n",
    "    \n",
    "        # visualization\n",
    "        #display(datepicker_from, datepicker_to, timeframe, stopwords_a23)\n",
    "        datepicker_from = widgets.DatePicker(description='Date starts', value=agg_actions['rev_time'].iloc[0], layout=Layout(width=\"25%\"))\n",
    "        datepicker_to = widgets.DatePicker(description='Date ends', value=agg_actions['rev_time'].iloc[-1], layout=Layout(width=\"25%\"))\n",
    "        timeframe = widgets.RadioButtons(options=['Monthly', 'Weekly', \"Daily\"], value='Monthly', description='Granularity:', layout={'width': '50%'})\n",
    "        stopwords_a23 = widgets.RadioButtons(options=['Not included', 'Included'], value='Not included', description='Stopwords', layout={'width': '50%'})\n",
    "        interact(listener.listen, _range1=datepicker_from,\n",
    "                 _range2=datepicker_to,\n",
    "                 granularity=timeframe,\n",
    "                 stopwords = stopwords_a23)\n",
    "        \n",
    "out21 = Output()\n",
    "display(out21)\n",
    "\n",
    "# # set the event\n",
    "button_a21.on_click(on_click_owned_tokens)\n",
    "\n",
    "# # trigger the event with the default value\n",
    "on_click_owned_tokens(button_a21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Load Actions' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### ------------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Get Editors Info' BUTTON ###\n",
    "### ------------------------------------------------------------------------------- ###\n",
    "\n",
    "## Create a TokensOwnedListener instance, more details can be found in             ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/tokens_listener.py ##\n",
    "owned_listener = TokensOwnedListener(total_actions, token_sources, lng=abbreviation(languageSelection.value))\n",
    "\n",
    "## Visualization, core visual code lies in TokensOwnedListener, then the interact function     ##\n",
    "## makes it interactive, mode details see:                                                 ##\n",
    "## https://github.com/gesiscss/wikiwho_demo/blob/master/visualization/tokens_listener.py  ##\n",
    "\n",
    "# This is the page you used\n",
    "print('The page that is being used:', the_page['title'], f'({abbreviation(languageSelection.value).upper()})')\n",
    "\n",
    "# Visualization: parameters\n",
    "begin_date = date(2005, 3, 22)\n",
    "end_date = date(2021, 2, 26)\n",
    "frequency = 'Monthly' # \"Monthly\", \"Weekly\", \"Daily\"\n",
    "stopwords = 'Not included'\n",
    "\n",
    "# Visualization: the stacked area plot\n",
    "owned_listener.listen(\n",
    "    _range1 = begin_date,\n",
    "    _range2 = end_date,\n",
    "    granularity = frequency,\n",
    "    stopwords = stopwords\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### -------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Show Tokens' BUTTON ###\n",
    "### -------------------------------------------------------------------------- ###\n",
    "\n",
    "## Create a TokensListener instance, more details see:                                       ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/tokens_listener.py ##\n",
    "tokens_listener = TokensListener(total_actions, token_sources, lng=abbreviation(languageSelection.value))\n",
    "\n",
    "## Visualization ##\n",
    "selected_rev = \"954896444\"\n",
    "include_stopwords = \"Not included\"  # included, Not included\n",
    "\n",
    "tokens_listener.listen(int(selected_rev), include_stopwords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.4 Editor activity drilldown -  Detailed information for each editor in a time frame\n",
    "\n",
    "We can explore individual editors in detail. The table below presents several metrics for each editor in Monthly/Weekly/Daily time frames. \n",
    "\n",
    "<p></p>\n",
    "\n",
    "<details>   \n",
    "<summary style=\"cursor: pointer;font-weight:bold\">Columns description of the editors table</summary>\n",
    "\n",
    "**General information:**\n",
    "    \n",
    "- **rev_time**: The time frame within which some revisions created by an editor fall. For example, when choosing \"Monthly\" time frame, \"2020-05-31\" denotes the whole month of May, 2020; when choosing \"Weekly\" time frame, \"2020-05-10\" denotes the week from 2020-05-04 to 2020-05-10 and it is always Sunday; when choosing \"Daily\" time frame, the \"rev_time\" simply indicates \"on that day\".\n",
    "- **editor**: the name of an editor that performed an action.\n",
    "- **editor_id**: the id of the editor that inserted the token (if starts with 0|, it means that the editor is not registered, and the ip is displayed instead)\n",
    "    \n",
    "**Metrics taking stopwords into consideration:**\n",
    "- **adds**: Number of first-time insertions (additions).\n",
    "- **dels**: Neditorsumber of deletions.\n",
    "- **reins**: Number of reinsertions.\n",
    "- **prod**: Productivity, ratio of all actions that survived at least 48h.\n",
    "- **SW_ratio**: Stopwords ratio, ratio of stopwords.\n",
    "- **revs**: Total number of the revisions created by this editor within some time frame.\n",
    "    \n",
    "**Metrics excluding stopwords:**\n",
    "- **conflict**: The sum of conflict scores of all actions divided by the number of elegible actions.\n",
    "- **main_op**: Main opponent, the previous editor who has the most conflict with the editor in this row, within some time frame.\n",
    "- **avg_reac_time**: Average reaction time of all elegible actions (dels + reins) of an editor within some time frame.\n",
    "</details>   \n",
    "\n",
    "You can click each row to to know which revisions a particular editor has created in that month/week/day. Then another table containing all revisions in that time frame with other relevant metrics will be provided underneath.\n",
    "\n",
    "<p></p>\n",
    "\n",
    "\n",
    "<details>   \n",
    "<summary style=\"cursor: pointer;font-weight:bold\">Columns description of the revisions table</summary>   \n",
    "\n",
    "In the second table, the definition of adds/dels/reins/prod/SW_ratio remains the same as the one for the editors table. Here are other metrics included:\n",
    "    \n",
    "- **main_op**: (Excluding stopwords) The previous editor who has the most conflict calculated using actions in this revision.\n",
    "- **min_reac**: (Excluding stopwords) The minimum length of the reaction time in this revision.\n",
    "- **Damaging**: The probability of being damaging edits provided by [ORES](https://www.mediawiki.org/wiki/ORES#Edit_quality)\n",
    "- **Goodfaith**: The probability of being non-damaging edits provided by [ORES](https://www.mediawiki.org/wiki/ORES#Edit_quality)\n",
    "    \n",
    "</details>\n",
    "\n",
    "Then, click one revision that interests you and this revision will be automatically filled in the input box in the next section (subsection B.1).\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ef48186427ac4f968047a0d6e888bdc3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Get Editors Info', layout=Layout(width='160px'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e13b9170c0c43569f33ae57602e8e9c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "searchRev = widgets.Text(description='Rev_id:')\n",
    "\n",
    "# create and display the button\n",
    "button_a2 = widgets.Button(description=\"Get Editors Info\", layout=Layout(width='160px'))\n",
    "\n",
    "display(button_a2)\n",
    "\n",
    "def on_click_editors(b):\n",
    "    global editor_listener\n",
    "    with out_a2:\n",
    "        clear_output()\n",
    "        \n",
    "        editor_listener = EditorsListener(agg_actions, sources, lng=abbreviation(languageSelection.value), search_widget=searchRev)\n",
    "        editor_listener.get_infos()\n",
    "        \n",
    "        display(md(f\"***Page: {the_page['title']} ({abbreviation(languageSelection.value).upper()})***\"))\n",
    "\n",
    "        datepicker_from = widgets.DatePicker(description='Date starts', value=agg_actions['rev_time'].iloc[0], layout=Layout(width=\"25%\"))\n",
    "        datepicker_to = widgets.DatePicker(description='Date ends', value=agg_actions['rev_time'].iloc[-1], layout=Layout(width=\"25%\"))\n",
    "        timeframe = widgets.RadioButtons(options=['Monthly', 'Weekly', \"Daily\"], value='Monthly', description='Granularity:', layout={'width': '50%'})\n",
    "        interact(editor_listener.listen,\n",
    "                 _range1=datepicker_from,\n",
    "                 _range2=datepicker_to,\n",
    "                 granularity=timeframe)\n",
    "    \n",
    "out_a2 = Output()\n",
    "display(out_a2)\n",
    "\n",
    "# set the event\n",
    "button_a2.on_click(on_click_editors)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_editors(button_a2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Load Actions' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### ------------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Get Editors Info' BUTTON ###\n",
    "### ------------------------------------------------------------------------------- ###\n",
    "\n",
    "## Create an EditorsListener instance and calculate, more details can be found in             ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/editors_listener.py ##\n",
    "editors_listener = EditorsListener(total_actions, token_sources, lng=abbreviation(languageSelection.value))\n",
    "editors_listener.get_infos()\n",
    "\n",
    "\n",
    "## Visualization, core visual code lies in EditorsListener, then the interact function     ##\n",
    "## makes it interactive, mode details see:                                                 ##\n",
    "## https://github.com/gesiscss/wikiwho_demo/blob/master/visualization/editors_listener.py  ##\n",
    "\n",
    "# This is the page you used\n",
    "print('The page that is being used:', the_page['title'], f'({abbreviation(languageSelection.value).upper()})')\n",
    "\n",
    "# Visualization: parameters\n",
    "begin_date = date(2007, 3, 1)\n",
    "end_date = date(2020, 5, 1)\n",
    "frequency = 'Monthly' # \"Monthly\", \"Weekly\", \"Daily\"\n",
    "\n",
    "the_latest_date = editors_listener.df.iloc[-1][\"rev_time\"].date()\n",
    "the_latest_editor = str(editors_listener.df.iloc[-1][\"editor_id\"])\n",
    "selected_date = the_latest_date  # Pick any datetime value from \"rev_time\" column, example: date(2020, 4, 30)\n",
    "selected_editor = the_latest_editor  # Pick any string value from \"editor_id\" column, example: \"17723088\"\n",
    "\n",
    "# Visualization: the first table with general info\n",
    "editors_listener.listen(\n",
    "    _range1 = begin_date,\n",
    "    _range2 = end_date,\n",
    "    granularity = frequency,\n",
    ")\n",
    "\n",
    "# Visualization: the second table with revision info\n",
    "print(f\"Within {frequency} timeframe, you have selected {editors_listener.names_id[selected_editor]}(id: {selected_editor})\")\n",
    "print(f\"The revisions fall in {str(selected_date)}\")\n",
    "print(f\"Link to revision history: https://{editors_listener.lng}.wikipedia.org/w/index.php?date-range-to=\\\n",
    "{str(selected_date)}&tagfilter=&title={the_page['title'].replace(' ', '_')}&action=history\")\n",
    "\n",
    "# Use RevisionsManager, more details see:\n",
    "# https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/editors_listener.py\n",
    "revisions_manager = editors_listener.revision_manager\n",
    "rev_table = revisions_manager.get_main(selected_date, selected_editor, frequency)\n",
    "display(rev_table)\n",
    "\n",
    "# Visualization: get the comment for this revision\n",
    "editors_listener.get_comments()  \n",
    "selected_rev = rev_table[\"rev_id\"].iloc[0]  # The first revision in the second table. You can also input another revision id if more are available.\n",
    "print(f\"Comment for the revision {selected_rev}: {editors_listener.rev_comments[editors_listener.selected_rev]}\")\n",
    "print(f\"Link to revisions diff: https://{editors_listener.lng}.wikipedia.org/w/index.php?diff={selected_rev}\\\n",
    "&title=TITLEDOESNTMATTER&diffmode=source\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "# B Text change inspection - Which text was changed?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "## B.1 Text change per revision - Which tokens were changed in a revision?\n",
    "\n",
    "The pre-selected revision corresponds to the latest revision of this article. You can enter a revision id manually, but we recommend to select a revision through the controls in the previous section (subsection A.4). \n",
    "\n",
    "Once you have selected the revisions, you can click \"Show tokens\" button."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed235936704f4201beda7679f43e5d49",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='1018064409', description='Rev_id:')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0751624becab4d4e8873f22f43936251",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RadioButtons(description='Stopwords', layout=Layout(width='50%'), options=('Not included', 'Included'), value=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c0f22b75563d46c596f9e9958ce91c8b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Show tokens', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c7ea319ef69148219c6982eba1e9a7e8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create and display the button\n",
    "button21 = widgets.Button(description=\"Show tokens\")\n",
    "\n",
    "def on_click_rev_tokens(b):\n",
    "    global listener\n",
    "    with out212:\n",
    "        clear_output()    \n",
    "        listener = TokensListener(agg_actions, sources, lng=abbreviation(languageSelection.value))\n",
    "        \n",
    "\n",
    "        # visualization\n",
    "        search_value = editor_listener.search_widget.value\n",
    "        #listener.rev_id = int(search_value)\n",
    "        listener.listen(int(search_value), stopwords_a22.value)\n",
    "        #out = interactive_output(listener.listen, {'stopwords':stopwords_a22})\n",
    "        #display(out)\n",
    "        \n",
    "        # preset filter to display only the selected revision\n",
    "        if len(listener.filtered_df) != 0:\n",
    "            listener.qgrid_selected_revision._handle_qgrid_msg_helper({\n",
    "                'type': 'show_filter_dropdown',\n",
    "                'field': 'rev_id',\n",
    "                'search_val': search_value})\n",
    "\n",
    "            listener.qgrid_selected_revision._handle_qgrid_msg_helper({\n",
    "                    'field': \"rev_id\",\n",
    "                    'filter_info': {\n",
    "                        'field': \"rev_id\",\n",
    "                        'selected': [0],\n",
    "                        'type': \"text\",\n",
    "                        'excluded': []\n",
    "                    },\n",
    "                    'type': \"change_filter\"\n",
    "                })\n",
    "        \n",
    "selected_rev = copy.copy(editor_listener.selected_rev)\n",
    "stopwords_a22 = widgets.RadioButtons(options=['Not included', 'Included'], value='Not included', description='Stopwords', layout={'width': '50%'})\n",
    "display(editor_listener.search_widget)\n",
    "display(stopwords_a22)\n",
    "display(button21)\n",
    "\n",
    "out212 = Output()\n",
    "display(out212)\n",
    "\n",
    "# set the event\n",
    "button21.on_click(on_click_rev_tokens)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_rev_tokens(button21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Show Tokens' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### -------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Show Tokens' BUTTON ###\n",
    "### -------------------------------------------------------------------------- ###\n",
    "\n",
    "## Create a TokensListener instance, more details see:                                       ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/tokens_listener.py ##\n",
    "tokens_listener = TokensListener(total_actions, token_sources, lng=abbreviation(languageSelection.value))\n",
    "\n",
    "## Visualization ##\n",
    "selected_rev = \"1005338891\"\n",
    "include_stopwords = \"Not included\"  # included, Not included\n",
    "\n",
    "tokens_listener.listen(int(selected_rev), include_stopwords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## B.2 Text change overall - Which tokens were changed overall?\n",
    "\n",
    "The following WordCloud and table present the 100 most popular token strings based on the amount of times that they are **added** or **undone (deleted/reinserted)**. \n",
    "\n",
    "The table on the bottom presents the detailed actions of each token.\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Explanation of the change action types</summary>\n",
    "   \n",
    "- **adds**: number of first-time insertions (additions)\n",
    "- **adds_48h**: number of adds that survived at least 48 hours\n",
    "- **adds_48h_ratio**: adds_48h / adds\n",
    "<br>\n",
    "\n",
    "- **dels**: number of deletions\n",
    "- **dels_48h**: number of deletions that were not resinserted in the next 48 hours\n",
    "- **dels_48h_ratio**: dels_48h / dels\n",
    "<br>\n",
    "\n",
    "- **reins**: number of reinsertions\n",
    "- **reins_48h**: number of reinsertions that survived at least 48 hours\n",
    "- **reins_48h_ratio**: reins_48h / reins\n",
    "</details>\n",
    "\n",
    "If you are insterested in a particular token, lick the token (row) in the table and another table containing all revision history of this token within the selected date range will appear beneath the first table. \n",
    "\n",
    "After that, you can investigate one particular action implemented on that token, then click that action (revision row) and a link to Wikipedia will be provided below for comparing different revisions.\n",
    "\n",
    "### \"Conflicts\" tab\n",
    "\n",
    "In the \"Conflicts\" tab, the WordCloud displays the top-100 conflicting token strings  i.e. the words with the most actions that are related to conflicts. The size of the token string in the WordCloud indicates frequency of actions (by default, only actions with conflict are used as *source* for the wordcloud).\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Source description</summary>\n",
    "    \n",
    "-   **Only Conflicts**: use only the actions that are in conflict.\n",
    "-   **Elegible Actions**: use only the actions that can potentially enter into conflict, i.e. actions \n",
    "that have occurred at least twice, e.g. the token x has been inserted twice (which necessarily implies \n",
    "it was remove once), the token x has been deleted twice (which necessarily implies it was inserted twice) \n",
    "-   **All Actions**: use all tokens regardles conflict\n",
    "</details>\n",
    "\n",
    "\n",
    "### \"Both\" tab\n",
    "\n",
    "In the \"Both\" tab, all the information is displayed simultaneusly in the follwing order: \n",
    "1. the top-100 conflicting token strings \n",
    "2. the 100 most popular token strings  \n",
    "3. the interactive table of actions of each token"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hide_input": true,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "60703b5cc4d845739ba34fadd223637b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButtons(description='Based on:', options=('All actions', 'Conflicts', 'Both'), tooltips=('Most frequent …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "56f95f2ba23f48f6a5403ba609ba7571",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Show WordCloud', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "76825971641f45f8bca0614ed2a712ca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create and display the button\n",
    "button3 = widgets.Button(description=\"Show WordCloud\")\n",
    "wc_select = widgets.ToggleButtons(options=['All actions', 'Conflicts', 'Both'], description='Based on:',\n",
    "    tooltips=['Most frequent words changed', 'Most frequent conflicting words', 'Both']\n",
    ")\n",
    "display(wc_select, button3)\n",
    "\n",
    "def on_click_wc_action(b):\n",
    "    with out12:\n",
    "        clear_output()\n",
    "    \n",
    "        listener = WCActionsListener(sources={\n",
    "            \"tokens_source\": sources,\n",
    "            \"tokens_inc_stop\": actions_inc_stop\n",
    "        }, lng=abbreviation(languageSelection.value))\n",
    "        \n",
    "        con_listener = WCListener(sources={\"tokens_source\": sources}, lng=abbreviation(languageSelection.value))\n",
    " \n",
    "\n",
    "        # visualization\n",
    "        date_from = sources[\"tokens_all\"][\"rev_time\"].iloc[0].date()\n",
    "        date_to = sources[\"tokens_all\"][\"rev_time\"].iloc[-1].date()\n",
    "        datepicker_from = widgets.DatePicker(description='Date starts', value=date_from, layout=Layout(width='25%'))\n",
    "        datepicker_to = widgets.DatePicker(description='Date ends', value=date_to, layout=Layout(width='25%'))\n",
    "        \n",
    "        _range1=datepicker_from\n",
    "        _range2=datepicker_to\n",
    "        action=Dropdown(options=['All', 'adds', 'adds_48h', 'dels', 'dels_48h', 'reins', 'reins_48h'], value='All', description='Action')\n",
    "        stopwords = widgets.RadioButtons(options=['Not included', 'Included'], value='Not included', description='Stopwords', layout={'width': '50%'})\n",
    "        \n",
    "        # conflict tokens visualization\n",
    "        source=Dropdown(options=['All Actions', 'Elegible Actions', 'Only Conflicts'], value='Only Conflicts', description='Source (*)')\n",
    "        con_action=Dropdown(options=['Both', 'Just Insertions', 'Just Deletions'], value='Both', description='Action')\n",
    "        editor=fixed('All')\n",
    "        \n",
    "        out = interactive_output(listener.listen, {'_range1': _range1, '_range2':_range2, 'action':action, 'stopwords':stopwords})\n",
    "        \n",
    "        con_out = interactive_output(con_listener.listen, {\n",
    "                 '_range1': datepicker_from,\n",
    "                 '_range2': datepicker_to,\n",
    "                 'source': source,\n",
    "                 'action': con_action,\n",
    "                 'editor': editor,\n",
    "                 'stopwords': stopwords\n",
    "        })\n",
    "\n",
    "        display(md(f\"***Page: {the_page['title']} ({abbreviation(languageSelection.value).upper()})***\"))\n",
    "                   \n",
    "        if wc_select.value == 'All actions':\n",
    "            display(VBox([datepicker_from, datepicker_to, action, stopwords, out]))\n",
    "        elif wc_select.value == 'Conflicts':\n",
    "            display(VBox([datepicker_from, datepicker_to, con_action, source, stopwords, con_out]))\n",
    "        else:\n",
    "            display(VBox([con_action, source, con_out]))\n",
    "            display(VBox([datepicker_from, datepicker_to, action, stopwords, out]))\n",
    "            \n",
    "\n",
    "\n",
    "        \n",
    "\n",
    "out12 = Output()\n",
    "display(out12)\n",
    "\n",
    "# set the event\n",
    "button3.on_click(on_click_wc_action)\n",
    "wc_select.observe(on_click_wc_action, 'value')\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_wc_action(button3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": true,
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Show WordCloud' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### -------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Show Word Cloud' BUTTON ###\n",
    "### -------------------------------------------------------------------------- ###\n",
    "\n",
    "wc_action_listener = WCActionsListener(sources={\n",
    "            \"tokens_source\": sources,\n",
    "            \"tokens_inc_stop\": actions_inc_stop\n",
    "        }, lng=abbreviation(languageSelection.value))\n",
    "\n",
    "wc_con_listener = WCListener(sources={\"tokens_source\": sources}, lng=abbreviation(languageSelection.value))\n",
    "\n",
    "# Parameters\n",
    "date_start = date(2005, 3, 22)\n",
    "date_end = date(2021, 2, 7)\n",
    "action_type = 'All'  #'All', 'adds', 'adds_48h', 'dels', 'dels_48h', 'reins', 'reins_48h'\n",
    "stopwords = \"Not included\" # 'included', 'Not included'\n",
    "\n",
    "# conflict tokens visualization\n",
    "source = 'All Actions' #'All Actions', 'Elegible Actions', 'Only Conflicts'\n",
    "conflict_action = 'Both' #'Both', 'Just Insertions', 'Just Deletions'\n",
    "editor='All'\n",
    "\n",
    "wc_action_listener.listen(_range1 = date_start, _range2 = date_end, action = action_type, stopwords = stopwords)\n",
    "\n",
    "# Uncomment this to plot the word cloud for conflicts        \n",
    "# wc_con_listener.listen(\n",
    "#                  _range1 = date_start,\n",
    "#                  _range2 = date_end,\n",
    "#                  source = source,\n",
    "#                  action = conflict_action,\n",
    "#                  editor = editor,\n",
    "#                  stopwords = stopwords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## B.3 Token-level conflicts - Conflict scores of individual change actions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following table, all the actions that are in conflict are presented, and a conflict score\n",
    "is presented per action. The importance of the conflict can be meassure by considering the seconds t that \n",
    "have passed since the last action on the same token (string) has occured (`time_diff_secs` column). A score to \n",
    "meassure conflict is calculated based on t with the following formula: 1 / log<sub>3600</sub>(t+2). \n",
    "Thus, *undo* actions are weighted higher than the original time in seconds when the *t* is less than an hour.\n",
    "For details, please refer to [Flöck et al, 2017](https://arxiv.org/abs/1703.08244).\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Columns description</summary>\n",
    "\n",
    "- **string**: the string of the token that is being tracked\n",
    "- **order**: numerical variable, shows the order of the conflicting actions in the revision history\n",
    "- **count**: numerical indicator of how often a given token is in the revision history\n",
    "- **token_id**: the id of the token that is being tracked\n",
    "- **rev_id**: the revision id in which the action (insertion or deletion) happen\n",
    "- **editor_name**: the name of an editor that performed an action\n",
    "- **editor_id**: the id of the editor that inserted the token (if starts with **0|**, it means that\n",
    "the editor is not registered, and the ip is displayed instead\n",
    "- **time_diff_secs**: seconds that have passed since the last action on the same token has occured\n",
    "- **conflict**: a score to meassure conflict that is calculated based on the `time_diff_secs` \n",
    "with the following formula: *1 / log<sub>3600</sub>(time_diff_secs + 2)*. For details, please refer to \n",
    "[Flöck et al, 2017](https://arxiv.org/abs/1703.08244)\n",
    "\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1d8c6d899c6e4f08a0eadab032c0fe8a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Show Conflict Score of Each Action', layout=Layout(width='250px'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7edbec4c305043ce9fa4c89e9573f196",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create and display the button\n",
    "button2 = widgets.Button(description=\"Show Conflict Score of Each Action\", layout=Layout(width='250px'))\n",
    "display(button2)\n",
    "\n",
    "def on_click_actions(b):\n",
    "    global conflictaction_listener\n",
    "    with out9:\n",
    "        clear_output()\n",
    "        \n",
    "        display(md(f\"***Page: {the_page['title']} ({abbreviation(languageSelection.value).upper()})***\"))\n",
    "        datepicker_from = widgets.DatePicker(description='Date starts', value=pd.to_datetime(revisions['rev_time'].iloc[0]), layout=Layout(width='25%'))\n",
    "        datepicker_to = widgets.DatePicker(description='Date ends', value=pd.to_datetime(revisions['rev_time'].iloc[-1]), layout=Layout(width='25%'))\n",
    "        \n",
    "        conflictaction_listener = ConflictsActionListener(sources={\n",
    "            \"tokens_source\": sources,\n",
    "            \"Editors\": editors,\n",
    "            \"Revisions\": revisions\n",
    "        },lng=abbreviation(languageSelection.value))\n",
    "               \n",
    "        stopwords = widgets.RadioButtons(options=['Not included', 'Included'], value='Not included', description='Stopwords', layout={'width': '50%'})\n",
    "        interact(conflictaction_listener.listen_to_interact, _range1 = datepicker_from, _range2 = datepicker_to, stopwords = stopwords)\n",
    "\n",
    "                      \n",
    "out9 = Output()\n",
    "display(out9)\n",
    "\n",
    "# set the event\n",
    "button2.on_click(on_click_actions)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_actions(button2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false,
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Show Conflict Score of Each Action' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hide_input": false,
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### --------------------------------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Show Conflict Score of Each Action' BUTTON   ###\n",
    "### --------------------------------------------------------------------------------------------------- ###\n",
    "\n",
    "## This is the page you used ##\n",
    "print('The page that is being used:', the_page['title'], f'({abbreviation(languageSelection.value).upper()})')\n",
    "\n",
    "## Create a ConflictsActionListener instance, more details see: ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/conflicts_listener.py#L178 ##\n",
    "# conflict_actions = ConflictsActionListener(sources={\n",
    "#             \"tokens_source\": token_sources,\n",
    "#             \"Editors\": grabbed_names,\n",
    "#             \"Revisions\": all_revisions\n",
    "#         },lng=abbreviation(languageSelection.value))\n",
    "\n",
    "## Visualization ##\n",
    "begin_date = date(2007, 3, 1)\n",
    "end_date = date(2020, 5, 1)\n",
    "include_stopwords = \"Not included\"  # \"Not inclueded\", \"Included\"\n",
    "revisionID = \"706448515\"  # Any revision id from rev_id column\n",
    "\n",
    "conflictaction_listener.listen(begin_date, end_date, include_stopwords)\n",
    "print(f\"Link to the wikipedia diff: https://{conflictaction_listener.lng}.wikipedia.org/w/index.php?&title={the_page['title'].replace(' ', '_')}&diff={revisionID}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# C. Wikipedia Talk page\n",
    "\n",
    "In this section, information about the associated Talk Page is presented. [Talk pages](https://en.wikipedia.org/wiki/Help:Talk_pages) are \"administration pages where editors can discuss improvements to articles\". In practice, Talk pages are also Wikipedia articles that can be accessed by adding `Talk:` before the name label in the url; for example, the talk page for https://en.wikipedia.org/wiki/The_Camp_of_the_Saints is called https://en.wikipedia.org/wiki/Talk:The_Camp_of_the_Saints. \n",
    "\n",
    "\n",
    "## C.1 Talk frequency - How are revisions in the talk section distributed over time?\n",
    "\n",
    "The following graph displays the number of revisions on the Talk page that is associated to the article that is being analyzed. This information is extracted directly from the [Wikipedia API](https://en.wikipedia.org/w/api.php). This information is also relevant to understand the conversations around conflictive periods that are observable in the time seried displayed in this notebook.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "92028b521d334d1eb95e22767960d22e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Load Talks', layout=Layout(width='160px'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "02d3b1e43c484166bf2eb7158d44e726",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "button_t = widgets.Button(description=\"Load Talks\", layout=Layout(width='160px'))\n",
    "display(button_t)\n",
    "\n",
    "def on_click_details(b):\n",
    "    global talk_content \n",
    "    with out_t:\n",
    "        clear_output()\n",
    "        display(md(f\"***Page: {the_page['title']} ({abbreviation(languageSelection.value).upper()})***\"))\n",
    "\n",
    "        #Initiate a Wikipedia instance\n",
    "        wikipediadv_instance = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "        \n",
    "        #Get content of revisions on talk page\n",
    "        talk_content = wikipediadv_instance.get_talk_content(the_talk_page[\"page_id\"])\n",
    "        \n",
    "        #convert to datetime format\n",
    "        talk_content['year_month'] = pd.to_datetime(talk_content['timestamp'])\n",
    "\n",
    "        \n",
    "        # Define a TalksListener instance\n",
    "        talks_listener = TalksListener(talk_content)\n",
    "\n",
    "        # Visualization\n",
    "        datepicker_from = widgets.DatePicker(description='Date starts', value=talk_content['year_month'].iloc[-1], layout=Layout(width='25%'))\n",
    "        datepicker_to = widgets.DatePicker(description='Date ends', value=talk_content['year_month'].iloc[0], layout=Layout(width='25%'))\n",
    "\n",
    "        interact(talks_listener.listen,\n",
    "            begin = datepicker_from,\n",
    "            end = datepicker_to,\n",
    "            granularity = Dropdown(options=['Monthly', 'Yearly', 'Daily'], value='Monthly')\n",
    "        )\n",
    "\n",
    "out_t = Output()\n",
    "display(out_t)\n",
    "\n",
    "# set the event\n",
    "button_t.on_click(on_click_details)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_details(button_t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is what will happen when you click 'Load Talks' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### -------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Load Talks' BUTTON  ###\n",
    "### -------------------------------------------------------------------------- ###\n",
    "\n",
    "## This is the page you used ##\n",
    "print('The page that is being used:', the_talk_page['title'])\n",
    "\n",
    "# Initiate a Wikipedia instance\n",
    "wikipediadv_instance = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "\n",
    "# Get content of revisions on talk page\n",
    "# more details see: https://github.com/gesiscss/wikiwho_demo_new/blob/master/external/wikipedia.py#L109\n",
    "talk_content = wikipediadv_instance.get_talk_content(the_talk_page[\"page_id\"])\n",
    "\n",
    "# convert to datetime format\n",
    "talk_content['year_month'] = pd.to_datetime(talk_content['timestamp'])\n",
    "\n",
    "## Define a TalksListener instance ##\n",
    "# more details see: https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/talks_listener.py\n",
    "talks_listener = TalksListener(talk_content)\n",
    "\n",
    "## Visualization ##\n",
    "begin_date = date(2005, 3, 1)\n",
    "end_date = date(2015, 7, 4)\n",
    "granularity = 'Monthly'\n",
    "\n",
    "print('Time range from', begin_date.strftime(\"%Y-%m-%d\"), 'to', end_date.strftime(\"%Y-%m-%d\"))\n",
    "talks_listener.listen(\n",
    "    begin = begin_date,\n",
    "    end = end_date,\n",
    "    granularity = granularity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## C.2 Talk topics - What are talk entries about?\n",
    "\n",
    "The topic of the talks under which the revisions happened are also available. The first table below shows the topic of each revision, sorted by date.  Although most of the times users change the content of the talk page, sometimes revisions include actions like signing a comment, deleting or reversing revisions. These actions are not presented in the table.\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Columns description</summary>\n",
    "\n",
    "- **topic**: the string topic extracted from revision content\n",
    "- **revid**: the revision id in which the action happened\n",
    "- **user**: the id or ip address of the editor that inserted the token\n",
    "- **year_month**: timestamp when the revision took place\n",
    "- **action_type**: type of the action made in a revision (new topic added or topic edited)\n",
    "\n",
    "</details>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "03bf2deafc5641f4a5391a6f62a6387e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Load Topics', layout=Layout(width='160px'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d964bbb9cca64b34bc8b06a127862abb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "button_to = widgets.Button(description=\"Load Topics\", layout=Layout(width='160px'))\n",
    "display(button_to)\n",
    "\n",
    "def on_click_topics(b):\n",
    "    global topics_listener, topic_df\n",
    "    with out_to:\n",
    "        clear_output()\n",
    "        display(md(f\"***Page: {the_talk_page['title']} ({abbreviation(languageSelection.value).upper()})***\"))\n",
    "\n",
    "        topics_listener = TopicsListener(talk_content)\n",
    "\n",
    "        #get a dataframe with topics and action_types\n",
    "        wikipediadv_ins = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "        topic_df = topics_listener.extract_topics(wikipediadv_ins)\n",
    "        \n",
    "                   \n",
    "        #adding transcluded content\n",
    "        tr_row = talk_content[talk_content['comment'].str.match(r'Transcluding GA review')==True]\n",
    "        if len(tr_row)>0:\n",
    "            wikipedia_dv = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "            transcluded_page = wikipedia_dv.get_page(the_talk_page['title'] +'/GA1')\n",
    "            transcluded_talk_content = wikipedia_dv.get_talk_content(transcluded_page[\"page_id\"])\n",
    "            transcluded_talk_content['year_month'] = pd.to_datetime(transcluded_talk_content['timestamp'])\n",
    "            tr_topics_listener = TopicsListener(transcluded_talk_content)\n",
    "            transcluded_topic_df = tr_topics_listener.translusion(wikipedia_dv).set_index('topics')\n",
    "            topics_listener.topic_df = topic_df.append(transcluded_topic_df).sort_values(by='year_month', ascending = False)\n",
    "        if len(topic_df) == 0:\n",
    "            display(md(\"There is no topics here!\"))\n",
    "        else:        \n",
    "            display(qgrid.show_grid(topics_listener.topic_df))\n",
    "\n",
    "            # Visualization\n",
    "            datepicker_from = widgets.DatePicker(description='Date starts', value=talk_content['year_month'].iloc[-1], layout=Layout(width='25%'))\n",
    "            datepicker_to = widgets.DatePicker(description='Date ends', value=talk_content['year_month'].iloc[0], layout=Layout(width='25%'))\n",
    "\n",
    "            interact(topics_listener.listen,\n",
    "                begin = datepicker_from,\n",
    "                end = datepicker_to,\n",
    "                granularity = Dropdown(options=['Monthly', 'Yearly', 'Daily'], value='Monthly')\n",
    "            )\n",
    "\n",
    "out_to = Output()\n",
    "display(out_to)\n",
    "\n",
    "# set the event\n",
    "button_to.on_click(on_click_topics)\n",
    "\n",
    "# trigger the event with the default value\n",
    "on_click_topics(button_to)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<span style=\"color: #626262\"> Try yourself! This is the code executed when you click the 'Load Topics' button: </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "%%script false --no-raise-error\n",
    "\n",
    "### IMPORTANT NOTE: COMMENT THE ABOVE LINE TO EXECUTE THE CELL ###\n",
    "\n",
    "### --------------------------------------------------------------------------- ###\n",
    "### TRY YOURSELF! THIS IS WHAT WILL HAPPEN WHEN YOU CLICK 'Show Topics' BUTTON  ###\n",
    "### --------------------------------------------------------------------------- ###\n",
    "\n",
    "## This is the page you used ##\n",
    "print('The page that is being used:', the_talk_page['title'])\n",
    "print(f\"Time range from {talk_content['year_month'].iloc[-1].date()} to {talk_content['year_month'].iloc[0].date()}\")\n",
    "\n",
    "## Initiate a topics listener, more details see:                                             ##\n",
    "## https://github.com/gesiscss/wikiwho_demo_new/blob/master/visualization/topics_listener.py ##\n",
    "topics_listener = TopicsListener(talk_content)\n",
    "\n",
    "# Get a dataframe with topics and action_types\n",
    "wikipediadv_ins = WikipediaDV(WikipediaAPI(lng=abbreviation(languageSelection.value)))\n",
    "topic_df = topics_listener.extract_topics(wikipediadv_ins)\n",
    "if len(topic_df) == 0:\n",
    "    print(\"There is no topics here!\")\n",
    "else:\n",
    "    display(qgrid.show_grid(topic_df))\n",
    "\n",
    "    # Visualization\n",
    "    begin_date = talk_content['year_month'].iloc[-1]  # date(xxxx.xx.xx)\n",
    "    end_date = talk_content['year_month'].iloc[0]  # date(xxxx.xx.xx)\n",
    "    granularity = 'Monthly'\n",
    "\n",
    "    topics_listener.listen(\n",
    "        begin = begin_date,\n",
    "        end = end_date,\n",
    "        granularity = granularity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Go to next workbook](./3_Focus_on_editor.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script>\n",
       "document.getElementById('notebook').scrollIntoView();\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lng_selected = abbreviation(languageSelection.value)\n",
    "#calculator = con_manager\n",
    "%store agg_actions\n",
    "#%store calculator\n",
    "#%store editors_conflicts\n",
    "%store lng_selected\n",
    "%store sources\n",
    "%store con_manager_all\n",
    "\n",
    "clear_output()\n",
    "# display(HTML(f'<a href=\"{get_next_notebook()}\" target=\"_blank\">Go to next workbook</a>'))\n",
    "# if len(editors_conflicts) > 0:\n",
    "#     display(HTML(f'<a href=\"{get_next_notebook()}\" target=\"_blank\">Go to next workbook</a>'))\n",
    "# else:\n",
    "#     display(HTML(f'<a href=\"{get_previous_notebook()}\" target=\"_blank\">Go back to the previous workbook</a>'))\n",
    "\n",
    "\n",
    "\n",
    "scroll_to_top = \"\"\"\n",
    "<script>\n",
    "document.getElementById('notebook').scrollIntoView();\n",
    "</script>\n",
    "\"\"\"\n",
    "\n",
    "display(HTML(scroll_to_top))"
   ]
  }
 ],
 "metadata": {
  "hide_input": true,
  "kernel_info": {
   "name": "python3"
  },
  "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.8.3"
  },
  "nteract": {
   "version": "0.14.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}