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"
    }
   ],
   "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()'))"
   ]
  },
  {
   "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": "code",
   "execution_count": 6,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94db8ec239bb4647be9ca38382a30460",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Language:', options=('English', 'Deutsch', 'Español', 'Türkçe', 'Euskara'), value='Engli…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "41219e0384804ce5afb615375f33b8c2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='The Camp of the Saints', description='Page title:')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7370bf30fce144e08bdd1b79eb014c84",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Search', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8c1c988e65d04502aab0c62777a89810",
       "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",
    "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": [
    "If you have input another page title and still want to use these variables in the next 4 notebooks, please refresh!"
   ]
  },
  {
   "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": {
    "hide_input": false
   },
   "source": [
    "---\n",
    "\n",
    "# A. Change actions and their impact\n",
    "\n",
    "**The dynamics of individual changes** to each word (and each special character) in the article are extracted by the [WikiWho API](https://www.wikiwho.net/en/api/v1.0.0-beta/). \n",
    "\n",
    "Below, you find several metrics for such change dynamics such as unsucessful/reverted changes and conflict. \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/) tracks the changes to every token (words or special characters) on a Wikipedia page with at least 95% accuracy, for live Wikipedia articles. It distinguishes every token in the document even when the string appears several times. E.g. \"and\" at the beginning of an article is a different token then \"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**. 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). Similarly, a **deletion** is also considered a **re-deletion** if the deletion has occured before.\n",
    "\n",
    "Formally, the token history can 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",
    "\n",
    "---\n",
    "\n",
    "*IMPORTANT:* For articles with a long revision history, please allow for some time to load, \n",
    "before interacting with the controls too often."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.1 Actions over time - When did certain change actions happen?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "In the following graph you can\n",
    "* select the *date range* and *granularity* (yearly, monthly) of the timeline (X-axis), and \n",
    "* plot any of the following *change action types* in the black, red, blue and green lines. \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\", 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 put back. I.e., 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\">Conflicts</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 -  was being 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 al.](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 \n",
    "conflict (or conflict actions).\n",
    "\n",
    "This total conflict can be normalized if the sum is divided by the number of \n",
    "actions that could potentially be counted as conflict (elegible actions, i.e **\"re-\"** actions that have occurred at \n",
    "least twice).\n",
    "\n",
    "The conflict scores in all notebooks are calculated based on the tokens excluding stopwords.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c8ec6ac119284d4b942b96cbdcae89bb",
       "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": "820297d7ae8844459e5ac61ccb2726ae",
       "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": 39,
   "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 part gives an overview of editors who have contributed and whose chanes have not been removed for 48 hours. This excludes, e.g., vandals and usually bad 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": "cdb4eb7403834545a561066979714d23",
       "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": "31366dfc730a43eaa64b8bc482f79ac4",
       "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": 37,
   "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 illustrates the number of tokens \"owned\" by 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. It is possible to select daily, weekly or monthly granularity, which simply means that the latest revision would be considered within a time window. For example, for daily period the latest revision during each day is considered. The number of total tokens existing on a page can be considered as the top line of a graph. <br/>\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": "2f601110d1d14f51985922a50f749065",
       "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": "8a07bc1b700b4f049d90c3f796a22f5b",
       "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": 35,
   "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": 34,
   "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 also provide more information for each individual editor. The table below presents several metrics for each editor in Monthly/Weekly/Daily time frames. If you want to know which revisions a particular editor has created in that month/week/day, please click that row. Then another table containing all revisions in that time frame with other relevant metrics will be provided underneath.\n",
    "Click one revision that interests you and this revision will be automatically filled in the input box in A2.2, just following next.\n",
    "<details>    \n",
    "    <summary style=\"cursor: pointer;font-weight:bold\">Columns description</summary>\n",
    "\n",
    "General information:\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**: Number 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",
    "\n",
    "In the second table, the definition of adds/dels/reins/prod/SW_ratio remains the same as above. For the other metrics:\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>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a1400708a0fa487d867d89d272263641",
       "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": "9618f3595fa846d0aea73a380169a2c6",
       "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": 31,
   "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",
    "Default revision is the latest revision of this article. To change the revision, you can enter a revision id manually or just click one row in the above table you are interested in and then 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": "a66380b0f3b24786bc845b5158449bb0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='1005338891', description='Rev_id:')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "33fa757728b546bea32b8473119221f9",
       "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": "e46d657eab0d4209a4cca072e4e1c45b",
       "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": "ef30e9cef3c04cc6a7c27c724a8a8017",
       "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": 29,
   "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 most 100 popular token strings that are either **added** or **undone (deleted/reinserted)**. The table also presents the detailed actions of each token.\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_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",
    "In case you are insterested in a particular token, e.g. \"racist\", just click 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. Furthermore, if you want to investigate one 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",
    "The WordCloud displays the most common conflicting token strings, i.e. words (token strings) \n",
    "with the most actions that have conflict. The size of the token string in the WordCloud indicates frequency \n",
    "of actions.\n",
    "In the controls you can select the *date range*, the type of *action* (insertion or deletion), and the \n",
    "*source*.\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>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b957fa59715f4f339295f17c5b180eb7",
       "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": "bd1d1a8505ec46f1b66889964aeaf296",
       "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": "a71ad254821a4f0b8366103ec6e35cfa",
       "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([datepicker_from, datepicker_to, action, stopwords, out]))\n",
    "            display(VBox([con_action, source, con_out]))\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",
    "<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",
    "<mark> *Question: Should explain -1 in the rev_id column?* </mark>\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": "98eb84061b144e60a483c83751611978",
       "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": "a357a6a99522403b8b94863acee8cba9",
       "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. Talk\n",
    "\n",
    "## C.1 Talk frequency - How are revisions in the talk section distributed over time?\n",
    "\n",
    "The Talk page activity represents the number of revisions on the Talk page of the Wikipedia article extracted by WikiWho API. \n",
    "\n",
    "In the controls you can select the *date range* and the *granularity*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "609e61f497844451a0d0594ec6067780",
       "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": "2ce97d7b52334e3bbbd310ab68057987",
       "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",
    "It is also possible to review what are the talks about by subsections, under which revisions happened. The 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",
    "<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",
    "The graph illustrates revisions by topics spread over time.\n",
    "\n",
    "In the controls for the graph you can select the *date range* and the *granularity*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "342d775732954d048f38e43daf83dba5",
       "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": "7b80dd81ce4243b99530f57380785d4e",
       "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 what will happen when you click '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",
       "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": [
    "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",
    "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",
    "scroll_to_top = \"\"\"\n",
    "<script>\n",
    "document.getElementById('notebook').scrollIntoView();\n",
    "</script>\n",
    "\"\"\"\n",
    "\n",
    "display(HTML(scroll_to_top))"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7.10"
  },
  "nteract": {
   "version": "0.14.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}