user_stats.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "\"\"\"Get user statistics from Wikipedia\"\"\"\n",
    "\n",
    "import logging\n",
    "import os\n",
    "import base64\n",
    "import json\n",
    "from dataclasses import dataclass, field\n",
    "from functools import cached_property\n",
    "from typing import Self\n",
    "\n",
    "from IPython.display import display\n",
    "import pandas\n",
    "import requests\n",
    "\n",
    "\n",
    "# %config Application.log_level='WORKAROUND'\n",
    "# => fails, necessary on Fedora 27, ipython3 6.2.1\n",
    "%config Application.log_level='INFO'\n",
    "\n",
    "logging.getLogger().setLevel(logging.INFO)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-10T20:38:04.568344Z",
     "start_time": "2024-04-10T20:38:04.556698Z"
    }
   },
   "id": "3e7c835ff35f971",
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class WikipediaAPI:\n",
    "    \"\"\"A class for interacting with the Wikipedia API.\"\"\"\n",
    "\n",
    "    lang: str\n",
    "\n",
    "    @property\n",
    "    def url(self) -> str:\n",
    "        \"\"\"Get the URL of the Wikipedia API endpoint.\n",
    "\n",
    "        :return: The URL of the Wikipedia API endpoint.\n",
    "        \"\"\"\n",
    "        return f\"https://{self.lang}.wikipedia.org/w/api.php\"\n",
    "\n",
    "    def call(\n",
    "        self, query: dict[str, str], method: str = \"get\"\n",
    "    ) -> dict[str, dict[str, str]]:\n",
    "        \"\"\"Sends an HTTP GET or POST request to the specified URL with the given query parameters.\n",
    "\n",
    "        :param query: A dictionary containing the query parameters for the request.\n",
    "        :param method: The HTTP method to be used for the request. Default is \"get\".\n",
    "        :return: A dictionary containing the response from the request, if successful.\n",
    "        \"\"\"\n",
    "        if method == \"get\":\n",
    "            result = requests.get(self.url, params=query, timeout=60)\n",
    "        elif method == \"post\":\n",
    "            result = requests.post(self.url, data=query, timeout=60)\n",
    "        else:\n",
    "            result = None\n",
    "\n",
    "        try:\n",
    "            result = result.json()\n",
    "\n",
    "        except ValueError:\n",
    "            logging.critical(f\"{self.url=}\")\n",
    "            logging.critical(f\"{query=}\")\n",
    "\n",
    "        return result\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class WikipediaUserContributionsPage:\n",
    "    \"\"\"Represents a Wikipedia user contributions page.\n",
    "\n",
    "    :param result: A list of dictionaries representing the user contributions.\n",
    "    :param next_info: A dictionary containing information about the next page of user contributions.\n",
    "    \"\"\"\n",
    "\n",
    "    result: list[dict[str, str]]\n",
    "    next_info: dict[str, str]\n",
    "\n",
    "    def to_dict(self) -> dict[str, dict[str, str]]:\n",
    "        \"\"\"Serializes the instance to a dictionary.\n",
    "\n",
    "        :return: A dictionary representation of the instance.\n",
    "        \"\"\"\n",
    "        return {\"result\": self.result, \"next_info\": self.next_info}\n",
    "\n",
    "    @classmethod\n",
    "    def from_dict(cls, user_contributions_page: dict[str, dict[str, str]]) -> Self:\n",
    "        \"\"\"Deserializes an instance of the class using a dictionary representation.\n",
    "\n",
    "        :param user_contributions_page: A dictionary containing user contribution page data.\n",
    "        :return: An instance of the class constructed using the provided dictionary.\n",
    "        \"\"\"\n",
    "        return cls(\n",
    "            result=user_contributions_page[\"result\"],\n",
    "            next_info=user_contributions_page[\"next_info\"],\n",
    "        )\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class WikipediaUserContributionsHelper:\n",
    "    \"\"\"Helper class to retrieve and cache user contributions from Wikipedia.\n",
    "\n",
    "    :param user_name: The username of the Wikipedia user.\n",
    "    :param lang: The language code of the Wikipedia.\n",
    "    :param next_info: The dictionary containing the values for pagination.\n",
    "    \"\"\"\n",
    "\n",
    "    user_name: str\n",
    "    lang: str\n",
    "    next_info: dict[str, str] = field(default=None)\n",
    "\n",
    "    @property\n",
    "    def params(self) -> dict[str, str]:\n",
    "        \"\"\"Returns the parameters to be used in the API request.\n",
    "\n",
    "        :return: A dictionary of parameters.\n",
    "        \"\"\"\n",
    "        params = {\n",
    "            \"action\": \"query\",\n",
    "            \"format\": \"json\",\n",
    "            \"list\": \"usercontribs\",\n",
    "            \"ucuser\": self.user_name,\n",
    "            \"uclimit\": \"500\",\n",
    "            \"continue\": \"\",\n",
    "            \"ucprop\": \"ids|title|timestamp|flags|tags|sizediff\",\n",
    "            \"formatversion\": \"2\",\n",
    "            \"ucdir\": \"newer\",\n",
    "        }\n",
    "        if self.next_info:\n",
    "            params[\"continue\"] = self.next_info[\"continue\"]\n",
    "            params[\"uccontinue\"] = self.next_info[\"uccontinue\"]\n",
    "        return params\n",
    "\n",
    "    @property\n",
    "    def _distant_contributions(self) -> WikipediaUserContributionsPage:\n",
    "        \"\"\"Retrieves the page of contributions from wikipedia.\n",
    "\n",
    "        :return: The user's distant contributions.\n",
    "        \"\"\"\n",
    "        logging.info(\"Getting data form wikipedia…\")\n",
    "        api: WikipediaAPI = WikipediaAPI(lang=self.lang)\n",
    "\n",
    "        request = api.call(self.params)\n",
    "\n",
    "        result = request[\"query\"][\"usercontribs\"]\n",
    "        next_info = request.get(\"continue\")\n",
    "\n",
    "        user_contributions_page = WikipediaUserContributionsPage(result, next_info)\n",
    "\n",
    "        return user_contributions_page\n",
    "\n",
    "    @property\n",
    "    def cached_contributions(self) -> WikipediaUserContributionsPage:\n",
    "        \"\"\"Returns a page of contributions from cache or get it from wikipedia.\n",
    "\n",
    "        :return: The page of contributions of the user.\n",
    "        \"\"\"\n",
    "        file_name = self.get_filename(self.next_info)\n",
    "        file_dir = f\"data/{self.lang}/{self.user_name}\"\n",
    "        file_path = f\"{file_dir}/{file_name}\"\n",
    "\n",
    "        user_contributions_page = None\n",
    "\n",
    "        if not os.path.exists(file_dir):\n",
    "            os.makedirs(file_dir)\n",
    "\n",
    "        if os.path.exists(file_path):\n",
    "            with open(file_path, \"r\", encoding=\"utf-8\") as contributions_page_file:\n",
    "                contributions_page = json.load(contributions_page_file)\n",
    "                user_contributions_page = WikipediaUserContributionsPage.from_dict(\n",
    "                    contributions_page\n",
    "                )\n",
    "                logging.info(\n",
    "                    f\"Loaded {len(user_contributions_page.result)} contributions information \"\n",
    "                    f\"in {file_path}\"\n",
    "                )\n",
    "                if not user_contributions_page.next_info:\n",
    "                    logging.info(\"This was the last cached page, we will re-query it.\")\n",
    "        if not user_contributions_page or not user_contributions_page.next_info:\n",
    "            user_contributions_page = self._distant_contributions\n",
    "            with open(file_path, \"w\", encoding=\"utf-8\") as contributions_page_file:\n",
    "                json.dump(user_contributions_page.to_dict(), contributions_page_file)\n",
    "                logging.info(\n",
    "                    f\"Saved {len(user_contributions_page.result)} contributions information \"\n",
    "                    f\"in {file_path}\"\n",
    "                )\n",
    "        return user_contributions_page\n",
    "\n",
    "    @staticmethod\n",
    "    def get_filename(next_info: dict[str, str]) -> str:\n",
    "        \"\"\"Converts a dictionary to a base64-encoded JSON string.\n",
    "\n",
    "        :param next_info: A dictionary containing the information to be converted.\n",
    "        :return: The base64 encoded JSON string.\n",
    "        \"\"\"\n",
    "        # Convert the dict to a JSON string\n",
    "        json_str = json.dumps(next_info)\n",
    "\n",
    "        # Convert the JSON string to bytes, so it can be encoded by base64\n",
    "        json_bytes = json_str.encode(\"utf-8\")\n",
    "\n",
    "        # Encode the bytes\n",
    "        base64_bytes = base64.b64encode(json_bytes)\n",
    "\n",
    "        # Convert the base64 bytes to a string for easier output and storage\n",
    "        base64_str = base64_bytes.decode(\"utf-8\")\n",
    "\n",
    "        return base64_str\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class WikipediaUser:\n",
    "    \"\"\"Represents a user on Wikipedia.\n",
    "\n",
    "    :param lang: the language of the Wikipedia site the user belongs to.\n",
    "    :param name: the username of the user.\n",
    "    \"\"\"\n",
    "\n",
    "    lang: str\n",
    "    name: str\n",
    "\n",
    "    def fetch_contribs(self) -> dict[str, str]:\n",
    "        \"\"\"Fetches the user contributions for the specified user and language.\n",
    "\n",
    "        :return: The user contributions.\n",
    "        \"\"\"\n",
    "\n",
    "        contributions = []\n",
    "        next_info = {\"uccontinue\": None, \"continue\": None}\n",
    "\n",
    "        while next_info:\n",
    "            uc_helper = WikipediaUserContributionsHelper(\n",
    "                self.name, self.lang, next_info=next_info\n",
    "            )\n",
    "            contributions_page = uc_helper.cached_contributions\n",
    "            contributions += contributions_page.result\n",
    "            next_info = contributions_page.next_info\n",
    "\n",
    "        return contributions\n",
    "\n",
    "\n",
    "class WikipediaNamespaces:\n",
    "    \"\"\"Retrieves the namespaces in Wikipedia.\n",
    "\n",
    "    :param lang: The language code of the Wikipedia site.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, lang=\"en\"):\n",
    "        self.lang = lang\n",
    "\n",
    "    @cached_property\n",
    "    def namespaces(self) -> dict[int:str]:\n",
    "        \"\"\"Retrieves the namespaces available in the Wikipedia API.\n",
    "\n",
    "        :return: A dictionary containing the namespace IDs as keys and the\n",
    "        corresponding namespace names as values.\n",
    "        \"\"\"\n",
    "        api = WikipediaAPI(lang=self.lang)\n",
    "\n",
    "        params = {\n",
    "            \"action\": \"query\",\n",
    "            \"meta\": \"siteinfo\",\n",
    "            \"siprop\": \"namespaces\",\n",
    "            \"format\": \"json\",\n",
    "            \"formatversion\": \"2\",\n",
    "        }\n",
    "\n",
    "        result = api.call(params)\n",
    "        namespaces = {\n",
    "            result[\"query\"][\"namespaces\"][namespace][\"id\"]: result[\"query\"][\n",
    "                \"namespaces\"\n",
    "            ][namespace].get(\"canonical\", \"Main\")\n",
    "            for namespace in result[\"query\"][\"namespaces\"]\n",
    "        }\n",
    "\n",
    "        return namespaces"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-10T20:48:43.053455Z",
     "start_time": "2024-04-10T20:48:42.915366Z"
    }
   },
   "id": "9592e4aa078a9387",
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class UserStats:\n",
    "    \"\"\"Analyses user statistics from Wikipedia.\n",
    "\n",
    "    :param user_name: The name of the user.\n",
    "    :param lang: The language of the Wikipedia site.\n",
    "    \"\"\"\n",
    "\n",
    "    user_name: str\n",
    "    lang: str\n",
    "\n",
    "    @cached_property\n",
    "    def user(self) -> WikipediaUser:\n",
    "        \"\"\"Returns the WikipediaUser object for the given username and language.\n",
    "\n",
    "        :return: An instance of WikipediaUser representing the user.\n",
    "        \"\"\"\n",
    "        return WikipediaUser(name=self.user_name, lang=self.lang)\n",
    "\n",
    "    @cached_property\n",
    "    def revisions(self) -> pandas.DataFrame:\n",
    "        \"\"\"Processes revisions information from the user's contributions.\n",
    "\n",
    "        :return:  The processed revisions' data.\n",
    "        \"\"\"\n",
    "        raw_revisions = pandas.DataFrame(self.user.fetch_contribs())\n",
    "        revisions = self.decode_namespaces(raw_revisions)\n",
    "        revisions = self.decode_dates(revisions)\n",
    "        revisions = self.add_absolute_sizediff(revisions)\n",
    "        return revisions\n",
    "\n",
    "    def decode_namespaces(self, revisions: pandas.DataFrame) -> pandas.DataFrame:\n",
    "        \"\"\"Decode namespaces\n",
    "\n",
    "        :param revisions: A pandas DataFrame containing revisions data.\n",
    "        :return: A pandas DataFrame with an additional column \"decoded_namespace\" that maps\n",
    "        the namespace codes in the \"ns\" column to their corresponding names.\n",
    "        \"\"\"\n",
    "        mediawiki_namespaces = WikipediaNamespaces(lang=self.lang).namespaces\n",
    "\n",
    "        revisions[\"decoded_namespace\"] = revisions[\"ns\"].map(mediawiki_namespaces)\n",
    "        return revisions\n",
    "\n",
    "    @staticmethod\n",
    "    def decode_dates(revisions: pandas.DataFrame) -> pandas.DataFrame:\n",
    "        \"\"\"Decode dates method takes a pandas DataFrame as input and decodes the timestamps\n",
    "        in the 'timestamp' column into datetime format.\n",
    "\n",
    "        :param revisions: The revisions' data.\n",
    "        :return: A pandas DataFrame with the 'date' column containing decoded datetime values.\n",
    "        \"\"\"\n",
    "        revisions[\"date\"] = pandas.to_datetime(revisions[\"timestamp\"])\n",
    "        return revisions\n",
    "\n",
    "    @staticmethod\n",
    "    def add_absolute_sizediff(revisions: pandas.DataFrame) -> pandas.DataFrame:\n",
    "        \"\"\"Add the absolute values of the \"sizediff\" column to the given DataFrame.\n",
    "\n",
    "        :param revisions: A pandas DataFrame containing the revisions data.\n",
    "        :return: A pandas DataFrame with an additional column named \"absolute_sizediff\" which\n",
    "        contains the absolute values of the \"sizediff\" column from the input DataFrame.\n",
    "        \"\"\"\n",
    "        revisions[\"absolute_sizediff\"] = revisions[\"sizediff\"].abs()\n",
    "        return revisions\n",
    "\n",
    "    def filtered_revisions(self, month: int, year: int) -> pandas.DataFrame:\n",
    "        \"\"\"Filters revisions based on the provided month and year.\n",
    "\n",
    "        :param month: The month for filtering revisions (1-12).\n",
    "        :param year: The year for filtering revisions.\n",
    "        :return: A pandas DataFrame containing the filtered revisions.\n",
    "        \"\"\"\n",
    "        mask = (self.revisions[\"date\"].dt.year == year) & (\n",
    "            self.revisions[\"date\"].dt.month == month\n",
    "        )\n",
    "        revisions_filtered = self.revisions[mask]\n",
    "        return revisions_filtered\n",
    "\n",
    "    @property\n",
    "    def revision_count(self) -> int:\n",
    "        \"\"\"Get the count of revisions.\n",
    "\n",
    "        :return: The count of revisions.\n",
    "        \"\"\"\n",
    "        return len(self.revisions)\n",
    "\n",
    "    @property\n",
    "    def revision_tags(self) -> list[str]:\n",
    "        \"\"\"Retrieve the unique revision tags from the revisions attribute.\n",
    "\n",
    "        :return: A list of unique revision tags.\n",
    "        \"\"\"\n",
    "        tags = self.revisions[\"tags\"].explode()\n",
    "        return tags.unique()\n",
    "\n",
    "    @property\n",
    "    def revision_keys(self) -> list[str]:\n",
    "        \"\"\"Retrieve the keys of the revisions.\n",
    "\n",
    "        :return: A list of keys from the revisions.\n",
    "        \"\"\"\n",
    "        return self.revisions.keys()\n",
    "\n",
    "    @property\n",
    "    def revision_namespaces(self) -> list[str]:\n",
    "        \"\"\"Returns a list of unique revision namespaces.\n",
    "\n",
    "        :return: A list of unique revision namespaces.\n",
    "        \"\"\"\n",
    "        namespaces = self.revisions[\"decoded_namespace\"]\n",
    "        return namespaces.unique()\n",
    "\n",
    "    def advanced_revisions_count_per_namespace(\n",
    "        self, month=None, year=None\n",
    "    ) -> pandas.DataFrame:\n",
    "        \"\"\"Get a pivot table for a given month and year or for the whole history with statistics\n",
    "        per namespaces.\n",
    "\n",
    "        :param month: The month for which to retrieve revisions (optional, default None)\n",
    "        :param year: The year for which to retrieve revisions (optional, default None)\n",
    "        :return: A DataFrame containing the advanced revisions count per namespace\n",
    "        \"\"\"\n",
    "        if month and year:\n",
    "            revisions = self.filtered_revisions(month, year)\n",
    "        else:\n",
    "            revisions = self.revisions.copy()\n",
    "\n",
    "        if len(revisions) > 0:\n",
    "\n",
    "            total_lines = revisions.shape[0]\n",
    "            total_diff_sizes = revisions[\"absolute_sizediff\"].sum()\n",
    "\n",
    "            # create a pivot table\n",
    "            pivot_table = revisions.pivot_table(\n",
    "                index=\"decoded_namespace\",\n",
    "                values=\"absolute_sizediff\",\n",
    "                aggfunc=[len, \"sum\"],\n",
    "            )\n",
    "\n",
    "            # Add a column for distinct pages\n",
    "            distinct_pages_pivot = revisions.pivot_table(\n",
    "                index=\"decoded_namespace\",\n",
    "                values=\"title\",\n",
    "                aggfunc=[pandas.Series.nunique],\n",
    "            )\n",
    "\n",
    "            # Join\n",
    "            pivot_table = pivot_table.join(distinct_pages_pivot)\n",
    "\n",
    "            # Rename columns\n",
    "            pivot_table.columns = [\n",
    "                \"count_of_lines\",\n",
    "                \"sum_of_diff_sizes\",\n",
    "                \"distinct_pages\",\n",
    "            ]\n",
    "\n",
    "            # calculate percentages\n",
    "            pivot_table[\"percentage_of_lines\"] = (\n",
    "                pivot_table[\"count_of_lines\"] / total_lines * 100\n",
    "            )\n",
    "            pivot_table[\"percentage_of_diff_sizes\"] = (\n",
    "                pivot_table[\"sum_of_diff_sizes\"] / total_diff_sizes * 100\n",
    "            )\n",
    "\n",
    "            # Sort the dataframe by 'percentage_of_lines' in descending order\n",
    "            pivot_table_sorted = pivot_table.sort_values(\n",
    "                \"percentage_of_lines\", ascending=False\n",
    "            )\n",
    "\n",
    "            # result\n",
    "            return pivot_table_sorted\n",
    "        return None\n",
    "\n",
    "    @property\n",
    "    def revisions_count_per_title(self) -> pandas.DataFrame:\n",
    "        \"\"\"Returns a pandas DataFrame with the count of revisions per title.\n",
    "\n",
    "        :return: A pandas DataFrame with two columns: \"title\" and \"count\".\n",
    "         The \"title\" column contains unique titles from the revisions dataset,\n",
    "         while the \"count\" column contains the corresponding count of revisions per title.\n",
    "\n",
    "        \"\"\"\n",
    "        return self.revisions[\"title\"].value_counts()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-10T20:38:04.615874Z",
     "start_time": "2024-04-10T20:38:04.604527Z"
    }
   },
   "id": "3e7d6fb597fcb2d",
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:Loaded 500 contributions information in data/fr/Florck/eyJ1Y2NvbnRpbnVlIjogbnVsbCwgImNvbnRpbnVlIjogbnVsbH0=\n",
      "INFO:root:Loaded 193 contributions information in data/fr/Florck/eyJ1Y2NvbnRpbnVlIjogIjIwMjQwNDAzMTg1NzA5fDIxMzkzOTQ4NCIsICJjb250aW51ZSI6ICItfHwifQ==\n",
      "INFO:root:This was the last cached page, we will re-query it.\n",
      "INFO:root:Getting data form wikipedia…\n",
      "INFO:root:Saved 194 contributions information in data/fr/Florck/eyJ1Y2NvbnRpbnVlIjogIjIwMjQwNDAzMTg1NzA5fDIxMzkzOTQ4NCIsICJjb250aW51ZSI6ICItfHwifQ==\n"
     ]
    },
    {
     "data": {
      "text/plain": "                   count_of_lines  sum_of_diff_sizes  distinct_pages  \\\ndecoded_namespace                                                      \nMain                          353             244228             183   \nTalk                          224             122170              30   \nProject                        55              43076              13   \nUser talk                      46              33831              12   \nUser                           12                862               6   \nProject talk                    4               1994               2   \n\n                   percentage_of_lines  percentage_of_diff_sizes  \ndecoded_namespace                                                 \nMain                         50.864553                 54.739881  \nTalk                         32.276657                 27.382492  \nProject                       7.925072                  9.654811  \nUser talk                     6.628242                  7.582689  \nUser                          1.729107                  0.193204  \nProject talk                  0.576369                  0.446924  ",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>count_of_lines</th>\n      <th>sum_of_diff_sizes</th>\n      <th>distinct_pages</th>\n      <th>percentage_of_lines</th>\n      <th>percentage_of_diff_sizes</th>\n    </tr>\n    <tr>\n      <th>decoded_namespace</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Main</th>\n      <td>353</td>\n      <td>244228</td>\n      <td>183</td>\n      <td>50.864553</td>\n      <td>54.739881</td>\n    </tr>\n    <tr>\n      <th>Talk</th>\n      <td>224</td>\n      <td>122170</td>\n      <td>30</td>\n      <td>32.276657</td>\n      <td>27.382492</td>\n    </tr>\n    <tr>\n      <th>Project</th>\n      <td>55</td>\n      <td>43076</td>\n      <td>13</td>\n      <td>7.925072</td>\n      <td>9.654811</td>\n    </tr>\n    <tr>\n      <th>User talk</th>\n      <td>46</td>\n      <td>33831</td>\n      <td>12</td>\n      <td>6.628242</td>\n      <td>7.582689</td>\n    </tr>\n    <tr>\n      <th>User</th>\n      <td>12</td>\n      <td>862</td>\n      <td>6</td>\n      <td>1.729107</td>\n      <td>0.193204</td>\n    </tr>\n    <tr>\n      <th>Project talk</th>\n      <td>4</td>\n      <td>1994</td>\n      <td>2</td>\n      <td>0.576369</td>\n      <td>0.446924</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "                   count_of_lines  sum_of_diff_sizes  distinct_pages  \\\ndecoded_namespace                                                      \nMain                          253             102341             145   \nTalk                          115              63491              17   \nProject                        43              32737               7   \nUser talk                      34              27738               8   \nUser                            5                 66               3   \n\n                   percentage_of_lines  percentage_of_diff_sizes  \ndecoded_namespace                                                 \nMain                         56.222222                 45.209013  \nTalk                         25.555556                 28.047073  \nProject                       9.555556                 14.461530  \nUser talk                     7.555556                 12.253228  \nUser                          1.111111                  0.029155  ",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>count_of_lines</th>\n      <th>sum_of_diff_sizes</th>\n      <th>distinct_pages</th>\n      <th>percentage_of_lines</th>\n      <th>percentage_of_diff_sizes</th>\n    </tr>\n    <tr>\n      <th>decoded_namespace</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Main</th>\n      <td>253</td>\n      <td>102341</td>\n      <td>145</td>\n      <td>56.222222</td>\n      <td>45.209013</td>\n    </tr>\n    <tr>\n      <th>Talk</th>\n      <td>115</td>\n      <td>63491</td>\n      <td>17</td>\n      <td>25.555556</td>\n      <td>28.047073</td>\n    </tr>\n    <tr>\n      <th>Project</th>\n      <td>43</td>\n      <td>32737</td>\n      <td>7</td>\n      <td>9.555556</td>\n      <td>14.461530</td>\n    </tr>\n    <tr>\n      <th>User talk</th>\n      <td>34</td>\n      <td>27738</td>\n      <td>8</td>\n      <td>7.555556</td>\n      <td>12.253228</td>\n    </tr>\n    <tr>\n      <th>User</th>\n      <td>5</td>\n      <td>66</td>\n      <td>3</td>\n      <td>1.111111</td>\n      <td>0.029155</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "                   count_of_lines  sum_of_diff_sizes  distinct_pages  \\\ndecoded_namespace                                                      \nTalk                          104              55903              14   \nMain                           99             141886              38   \nProject                        12              10339               7   \nUser talk                      12               6093               5   \nUser                            7                796               3   \nProject talk                    4               1994               2   \n\n                   percentage_of_lines  percentage_of_diff_sizes  \ndecoded_namespace                                                 \nTalk                         43.697479                 25.760445  \nMain                         41.596639                 65.381939  \nProject                       5.042017                  4.764275  \nUser talk                     5.042017                  2.807692  \nUser                          2.941176                  0.366802  \nProject talk                  1.680672                  0.918847  ",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>count_of_lines</th>\n      <th>sum_of_diff_sizes</th>\n      <th>distinct_pages</th>\n      <th>percentage_of_lines</th>\n      <th>percentage_of_diff_sizes</th>\n    </tr>\n    <tr>\n      <th>decoded_namespace</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Talk</th>\n      <td>104</td>\n      <td>55903</td>\n      <td>14</td>\n      <td>43.697479</td>\n      <td>25.760445</td>\n    </tr>\n    <tr>\n      <th>Main</th>\n      <td>99</td>\n      <td>141886</td>\n      <td>38</td>\n      <td>41.596639</td>\n      <td>65.381939</td>\n    </tr>\n    <tr>\n      <th>Project</th>\n      <td>12</td>\n      <td>10339</td>\n      <td>7</td>\n      <td>5.042017</td>\n      <td>4.764275</td>\n    </tr>\n    <tr>\n      <th>User talk</th>\n      <td>12</td>\n      <td>6093</td>\n      <td>5</td>\n      <td>5.042017</td>\n      <td>2.807692</td>\n    </tr>\n    <tr>\n      <th>User</th>\n      <td>7</td>\n      <td>796</td>\n      <td>3</td>\n      <td>2.941176</td>\n      <td>0.366802</td>\n    </tr>\n    <tr>\n      <th>Project talk</th>\n      <td>4</td>\n      <td>1994</td>\n      <td>2</td>\n      <td>1.680672</td>\n      <td>0.918847</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_user = UserStats(user_name=\"Florck\", lang=\"fr\")\n",
    "display(my_user.advanced_revisions_count_per_namespace())\n",
    "display(my_user.advanced_revisions_count_per_namespace(month=3, year=2024))\n",
    "display(my_user.advanced_revisions_count_per_namespace(month=4, year=2024))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-10T20:48:48.895918Z",
     "start_time": "2024-04-10T20:48:47.952935Z"
    }
   },
   "id": "f8cece5516296e62",
   "execution_count": 8
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}