mw-lifecycle-analysis/phab_analysis/case2/040425_phab_comments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba9e5acd-e17d-4318-9272-04c9f6706186",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import spacy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e4f0b3f0-5255-46f1-822f-e455087ba315",
   "metadata": {},
   "outputs": [],
   "source": [
    "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case2/0514_https_phab_comments.csv\"\n",
    "phab_df = pd.read_csv(phab_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ac5e624b-08a4-4ede-bc96-cfc26c3edac3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def http_relevant(text):\n",
    "    if pd.isnull(text):\n",
    "        return False\n",
    "    # expanded dictionary for relevancy\n",
    "    # http, login, SSL, TLS, certificate \n",
    "    for word in text.split():\n",
    "        if \"://\" not in word.lower():\n",
    "            #http\n",
    "            if \"http\" in word.lower():\n",
    "                return True\n",
    "            #login\n",
    "            if \"login\" in word.lower():\n",
    "                return True\n",
    "            #ssl\n",
    "            if \"ssl\" in word.lower():\n",
    "                return True\n",
    "            #tls\n",
    "            if \"tls\" in word.lower():\n",
    "                return True\n",
    "            #cert\n",
    "            if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n",
    "                return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d5925c49-ea1d-4813-98aa-eae10d5879ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_migrated(comment_text):\n",
    "    if pd.isnull(comment_text):\n",
    "        return False\n",
    "    text = comment_text.strip()\n",
    "    if text.startswith(\"Originally from: http://sourceforge.net\"):\n",
    "        return True \n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d449164e-1d28-4580-9eb1-f0f69978f114",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/3758790231.py:41: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
      "/tmp/ipykernel_55861/3758790231.py:44: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n"
     ]
    }
   ],
   "source": [
    "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n",
    "phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n",
    "\n",
    "#cleaning df\n",
    "phab_df['id'] = phab_df.index + 1\n",
    "#may have to build out the reply_to column \n",
    "phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n",
    "phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n",
    "\n",
    "phab_df = phab_df.rename(columns={\n",
    "    'AuthorPHID': 'speaker',\n",
    "    'TaskPHID': 'conversation_id',\n",
    "    'WMFaffil':'meta.affil',\n",
    "    'isGerrit': 'meta.gerrit'\n",
    "})\n",
    "\n",
    "# after 9-3-2011 before 11-27-2013\n",
    "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n",
    "filtered_phab_df = phab_df[(phab_df['date_created'] <  1385596799) & (phab_df['date_created'] > 1315008000)]\n",
    "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n",
    "\n",
    "#removing headless conversations\n",
    "task_phab_df = filtered_phab_df[filtered_phab_df['comment_type']==\"task_description\"]\n",
    "headed_task_phids = task_phab_df['conversation_id'].unique()\n",
    "filtered_phab_df = filtered_phab_df[filtered_phab_df['conversation_id'].isin(headed_task_phids)]\n",
    "\n",
    "#removing gerrit comments \n",
    "mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n",
    "\n",
    "# filter out the sourceforge migration \n",
    "# Originally from: http://sourceforge.net in the task task_summary\n",
    "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n",
    "\n",
    "#cut down to only the data that is relevant (mentions http)\n",
    "relevant_conversation_ids = task_phab_df[\n",
    "    task_phab_df['comment_text'].apply(http_relevant) |\n",
    "    task_phab_df['task_title'].apply(http_relevant)\n",
    "]['conversation_id'].unique()\n",
    "\n",
    "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "\n",
    "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "\n",
    "comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n",
    "task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n",
    "#comment_phab_df = mid_comment_phab_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "942344db-c8f5-4ed6-a757-c97f8454f18b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique conversation_ids: 1074\n",
      "Unique ids: 6515\n",
      "Unique speakers: 305\n"
     ]
    }
   ],
   "source": [
    "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n",
    "unique_ids = len(comment_phab_df['id'].unique())\n",
    "unique_speakers = len(comment_phab_df['speaker'].unique())\n",
    "\n",
    "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n",
    "print(f\"Unique ids: {unique_ids}\")\n",
    "print(f\"Unique speakers: {unique_speakers}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d226d781-b002-4842-a3ae-92d4851a5878",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def preprocess_text(text):\n",
    "    text = str(text)\n",
    "    text = text.replace('*', ' ')\n",
    "    text = text.replace('-', ' ')\n",
    "    text = re.sub(r'http\\S+', '', text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/2783900859.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "nlp = spacy.load(\"en_core_web_sm\")\n",
    "\n",
    "def extract_dependency_tree(text):\n",
    "    doc = nlp(text)\n",
    "    dependency_trees = []\n",
    "    \n",
    "    for sentence in doc.sents:\n",
    "        for token in sentence:\n",
    "            token_info = (\n",
    "                token.text, \n",
    "                token.lemma_, \n",
    "                token.dep_, \n",
    "                token.head.text, \n",
    "                list(token.ancestors), \n",
    "                list(token.subtree), \n",
    "                list(token.children)\n",
    "            )\n",
    "            dependency_trees.append(token_info)\n",
    "        \n",
    "    return dependency_trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/2805711855.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "337a528a-5667-4e1f-ac9a-37caabc03a18",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "e3364ab1-1879-4b89-8b3b-6ab5449fccfa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "114      After last update via SVN bot does not work, s...\n",
       "156      Timestamp has been changed since 27th septembe...\n",
       "176      **Author:** `happy.melon.wiki`\\n\\n**Descriptio...\n",
       "246      Steps to reproduce\\n1) Login to translatewiki....\n",
       "370      Recently, several refs are not accessible thro...\n",
       "                               ...                        \n",
       "45008    We have reports that since the HTTPS enabling,...\n",
       "45245    ssh is quite painful over a slow and/or lossy ...\n",
       "45299    The problem:\\nEspecially during lightning depl...\n",
       "45372    There are many pages for which VisualEditor is...\n",
       "46077    **Author:** `ka.hing.chan`\\n\\n**Description:**...\n",
       "Name: comment_text, Length: 382, dtype: object"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "task_phab_df['comment_text']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#get VAD scores\n",
    "import numpy as np\n",
    "#https://saifmohammad.com/WebPages/nrc-vad.html\n",
    "column_headings = ['Word', 'Valence', 'Arousal', 'Domination']\n",
    "vad_lexicon = pd.read_csv('NRC-VAD-Lexicon.txt', delimiter='\\t', header=None, names=column_headings)\n",
    "vad_dict = vad_lexicon.set_index('Word').T.to_dict()\n",
    "\n",
    "def vad_scoring(dependency_tree):\n",
    "    valence = []\n",
    "    arousal = []\n",
    "    dominance = []\n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            valence.append(vad_dict[lemma]['Valence'])\n",
    "            arousal.append(vad_dict[lemma]['Arousal'])\n",
    "            dominance.append(vad_dict[lemma]['Domination'])\n",
    "\n",
    "    # Compute average scores across the comment\n",
    "    avg_valence = np.mean(valence) if valence else 0\n",
    "    avg_arousal = np.mean(arousal) if arousal else 0\n",
    "    avg_dominance = np.mean(dominance) if dominance else 0\n",
    "\n",
    "    return [avg_valence, avg_arousal, avg_dominance]\n",
    "\n",
    "def dominance_prevail(dependency_tree):\n",
    "    dominant_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Domination'] >= 0.75:\n",
    "                dominant_words += 1\n",
    "            if vad_dict[lemma]['Domination'] <= 0.25:\n",
    "                dominant_words += 1\n",
    "    return dominant_words\n",
    "\n",
    "def arousal_prevail(dependency_tree):\n",
    "    arousal_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Arousal'] >= 0.75:\n",
    "                arousal_words += 1\n",
    "            if vad_dict[lemma]['Arousal'] <= 0.25:\n",
    "                arousal_words += 1\n",
    "    return arousal_words\n",
    "\n",
    "def valence_prevail(dependency_tree):\n",
    "    valence_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Valence'] >= 0.75:\n",
    "                valence_words += 1\n",
    "            if vad_dict[lemma]['Valence'] <= 0.25:\n",
    "                valence_words += 1\n",
    "    return valence_words\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "828fb57a-e152-42ef-9c60-660648898532",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/2858732056.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n",
      "/tmp/ipykernel_55861/2858732056.py:3: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n",
      "/tmp/ipykernel_55861/2858732056.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n",
      "/tmp/ipykernel_55861/2858732056.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)\n"
     ]
    }
   ],
   "source": [
    "#establishing per-comment VAD scores \n",
    "comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n",
    "comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n",
    "comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n",
    "comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "27e47f6f-0257-4b70-b222-e91ef888c900",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/335308388.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
      "/tmp/ipykernel_55861/335308388.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
      "/tmp/ipykernel_55861/335308388.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
    "comment_phab_df = comment_phab_df.drop(columns=['avg_vad_scores'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# expand the dependency parser \n",
    "\n",
    "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n",
    "#pattern = r'\\b(WMF|Foundation)\\b'\n",
    "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n",
    "pattern = r'\\b(http|https)\\b'\n",
    "\n",
    "dependency_relations = []\n",
    "resolved_dependency_relations = []\n",
    "\n",
    "for index, row in comment_phab_df.iterrows():\n",
    "    text = row['comment_text']\n",
    "    timestamp = row['timestamp']\n",
    "    comment_id = row['id']\n",
    "    conversation_id = row['conversation_id']\n",
    "    WMFaffil = row['meta.affil']\n",
    "    \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''        \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            resolved_dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''\n",
    "#resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations)            \n",
    "dependency_relations_df = pd.DataFrame(dependency_relations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "82498686-14f4-40c8-9e33-27b31f115b47",
   "metadata": {},
   "outputs": [],
   "source": [
    "#now analysis/plotting \n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.gridspec import GridSpec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "82cd9dde-0d14-4de5-8482-5a39de8d2869",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/1194677655.py:37: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "#task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n",
    "task_phab_df = task_phab_df[task_phab_df['is_relevant'] == True]\n",
    "task_phab_df['first_comment'] = task_phab_df.groupby('speaker')['timestamp'].rank(method='first') <= 5\n",
    "#task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1383264000) & (task_phab_df['date_created'] > 1351728000)]\n",
    "\n",
    "'''\n",
    "task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "unique_taskPHIDs = task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "wmf_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] == True)]\n",
    "wmf_tasks = wmf_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "other_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] != True)]\n",
    "other_tasks = other_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "unaff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] != True)]\n",
    "unaff_new_tasks = unaff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "aff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] == True)]\n",
    "aff_new_tasks = aff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "sns.lineplot(x=unique_taskPHIDs.index, y=unique_taskPHIDs.values, color='black', label='Total', marker='o')\n",
    "sns.lineplot(x=wmf_tasks.index, y=wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors', marker='o')\n",
    "sns.lineplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n",
    "#sns.lineplot(x=aff_new_tasks.index, y=aff_new_tasks.values, color='#c7756a',linestyle=\"dotted\", label=\"WMF-affiliated new authors\", marker='x')\n",
    "#sns.lineplot(x=unaff_new_tasks.index, y=unaff_new_tasks.values, color='#5da2d8', linestyle=\"dotted\", label=\"Nonaffiliated new authors\", marker='x')\n",
    "\n",
    "plt.title('New Relevant Phabricator Tasks Indexed with HTTPS')\n",
    "plt.xlabel('Timestamp')\n",
    "plt.ylabel('Unique taskPHIDs')\n",
    "plt.xticks(rotation=45)\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "'''\n",
    "task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "unique_taskPHIDs = task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "wmf_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] == True)]\n",
    "wmf_tasks = wmf_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "other_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] != True)]\n",
    "other_tasks = other_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "sns.barplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors')\n",
    "sns.barplot(x=wmf_tasks.index, y=-wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors')\n",
    "\n",
    "plt.title('New Relevant Phabricator Tasks Indexed with HTTP')\n",
    "plt.xlabel('Timestamp')\n",
    "plt.ylabel('Unique taskPHIDs')\n",
    "plt.xticks(rotation=90)\n",
    "# Customize the x-axis for weekly labels\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031825_new_tasks_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9a9b08a7-6c95-4971-b259-8e713c58fbe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/2282722856.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
      "/tmp/ipykernel_55861/2282722856.py:17: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
      "/tmp/ipykernel_55861/2282722856.py:18: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
      "/tmp/ipykernel_55861/2282722856.py:20: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#task_phab_df = phab_df[phab_df['comment_type'] == \"task_description\"]\n",
    "unaff_tasks_phab_df = task_phab_df[task_phab_df['meta.affil'] != True]\n",
    "# Rank speaker's task values within each group\n",
    "unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "\n",
    "# Filter dates 08-01-2013 to 11-27-2013\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df[(unaff_tasks_phab_df['date_created'] < 1385596799) & (unaff_tasks_phab_df['date_created'] > 1375315200)]\n",
    "# Bin the speakers based on the number of tasks they created\n",
    "bins = [0, 6, 26, 51, float('inf')]\n",
    "labels = ['0-5', '6-25', '26-50', '51+']\n",
    "min_speakers_task = unaff_tasks_phab_df.groupby('speaker')['speakers_task'].min().reset_index()\n",
    "min_speakers_task = min_speakers_task.rename(columns={'speakers_task': 'min_speakers_task'})\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df.merge(min_speakers_task, on='speaker', how='left')\n",
    "unaff_tasks_phab_df['task_bins'] = pd.cut(unaff_tasks_phab_df['min_speakers_task'], bins=bins, labels=labels, right=False)\n",
    "\n",
    "# Calculate the weekly breakdown of binned speakers_task values\n",
    "unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
    "\n",
    "speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n",
    "\n",
    "# Reshape the DataFrame for use with Seaborn\n",
    "weekly_breakdown = weekly_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='count')\n",
    "speaker_breakdown = speaker_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='speakers')\n",
    "\n",
    "# Plot the stacked bar plot using Seaborn\n",
    "plt.figure(figsize=(12, 8))\n",
    "sns.barplot(data=weekly_breakdown, x='week', y='count', hue='task_bins', palette='colorblind')\n",
    "#sns.barplot(data=speaker_breakdown, x='week', y='speakers', hue='task_bins', palette='colorblind')\n",
    "plt.title(\"08-01-2013 to 11-27-2013 Weekly Unaffiliated Task Creation by Contributor Tenure\")\n",
    "plt.xlabel('Week')\n",
    "plt.ylabel('Tasks')\n",
    "plt.legend(title=\"Contributor had created # tasks between 09-03-2011 and 08-01-2013:\")\n",
    "plt.xticks(rotation=45)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031625_weekly_tasks_by_history.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b7cfad77-d48a-4708-91f3-89ae1179b90c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_55861/2708736932.py:27: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
      "/tmp/ipykernel_55861/2708736932.py:28: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
      "/tmp/ipykernel_55861/2708736932.py:35: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
      "/tmp/ipykernel_55861/2708736932.py:36: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of comments for each date group:\n",
      "date_group\n",
      "Before announcement                      4890\n",
      "After announcement, before deployment     328\n",
      "After deployment                         1297\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group:\n",
      "date_group\n",
      "Before announcement                      243\n",
      "After announcement, before deployment     73\n",
      "After deployment                         162\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         1927\n",
      "                                                      True            38\n",
      "                                       True           False         2832\n",
      "                                                      True            93\n",
      "After announcement, before deployment  False          False          134\n",
      "                                                      True             4\n",
      "                                       True           False          170\n",
      "                                                      True            20\n",
      "After deployment                       False          False          658\n",
      "                                                      True            22\n",
      "                                       True           False          600\n",
      "                                                      True            17\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         221\n",
      "                                                      True           14\n",
      "                                       True           False          20\n",
      "                                                      True           15\n",
      "After announcement, before deployment  False          False          52\n",
      "                                                      True            4\n",
      "                                       True           False          18\n",
      "                                                      True            9\n",
      "After deployment                       False          False         141\n",
      "                                                      True           11\n",
      "                                       True           False          19\n",
      "                                                      True            5\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         2719\n",
      "               True            64\n",
      "True           False         3602\n",
      "               True           130\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         280\n",
      "               True           26\n",
      "True           False          20\n",
      "               True           16\n",
      "Name: speaker, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nplot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'new_commenter\\', scatter=False, legend=False, palette=palette)\\nplot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\\nplot1.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\\nplot1.add_legend(title=\"Comment publication timestamp:\")\\nfig1 = plot1.fig\\n# Plot for arousal_wc\\nplot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\\nplot2.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot2.add_legend(title=\"Comment publication timestamp:\")\\n#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\\n\\nplot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\\nplot3.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot3.add_legend(title=\"Comment publication timestamp:\")\\n'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1333.5x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = [\n",
    "    pd.Timestamp('1900-01-01 00:00:01+00:00'),\n",
    "    pd.Timestamp('2013-08-01 00:00:01+00:00'),\n",
    "    pd.Timestamp('2013-08-28 00:00:01+00:00'),\n",
    "    pd.Timestamp('2100-08-28 00:00:01+00:00')\n",
    "]\n",
    "labels = ['Before announcement', 'After announcement, before deployment', 'After deployment']\n",
    "\n",
    "#creating variables of interest\n",
    "affective_comment_phab_df = comment_phab_df\n",
    "affective_comment_phab_df['date_group'] = pd.cut(affective_comment_phab_df['timestamp'], bins=bins, labels=labels, right=False)\n",
    "affective_comment_phab_df['speakers_comment'] = affective_comment_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "#all comments prior to june 1 2013\n",
    "subset_comment_phab_df = affective_comment_phab_df[affective_comment_phab_df['date_created'] <= 1370044800]\n",
    "#getting counts \n",
    "comment_counts = subset_comment_phab_df.groupby('speaker')['speakers_comment'].max().reset_index()\n",
    "comment_counts = comment_counts.rename(columns={'speakers_comment': 'pre_june_2013_comments'})\n",
    "#merge back \n",
    "affective_comment_phab_df = affective_comment_phab_df.merge(comment_counts, on='speaker', how='left')\n",
    "affective_comment_phab_df['pre_june_2013_comments'] = affective_comment_phab_df['pre_june_2013_comments'].fillna(0)\n",
    "\n",
    "affective_comment_phab_df['new_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] <= 10\n",
    "affective_comment_phab_df['est_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] > 50\n",
    "\n",
    "palette = ['#31449c', '#4a7c85', '#c5db68']\n",
    "\n",
    "comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
    "speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
    "\n",
    "print(\"Number of comments for each date group:\")\n",
    "print(comment_counts)\n",
    "print(\"\\nNumber of speakers for each date group:\")\n",
    "print(speaker_counts)\n",
    "\n",
    "comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each date group and engaged commenter subgroup:\")\n",
    "print(comment_counts_engaged)\n",
    "print(\"\\nNumber of speakers for each date group and engaged commenter subgroup:\")\n",
    "print(speaker_counts_engaged)\n",
    "\n",
    "comment_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(comment_counts_wmf)\n",
    "print(\"\\nNumber of speakers for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(speaker_counts_wmf)\n",
    "\n",
    "#comment_phab_df['before_after'] = comment_phab_df['timestamp'] > pd.Timestamp('2013-07-01 00:00:01+00:00')\n",
    "#fig, axes = plt.subplots(2, 1, figsize=(10, 12), sharex=True)\n",
    "affective_comment_phab_df['polarized_wc'] = affective_comment_phab_df['dominant_wc'] + affective_comment_phab_df['valence_wc'] + affective_comment_phab_df['arousal_wc'] \n",
    "plot1 = sns.lmplot(data=affective_comment_phab_df, x=\"date_created\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", row='est_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Established Author: {row_name}\", col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "'''\n",
    "plot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row='new_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "# Plot for arousal_wc\n",
    "plot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\n",
    "plot2.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot2.add_legend(title=\"Comment publication timestamp:\")\n",
    "#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\n",
    "\n",
    "plot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\n",
    "plot3.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot3.add_legend(title=\"Comment publication timestamp:\")\n",
    "'''\n",
    "# Show plots\n",
    "#fig1.savefig('031725_engaged_commenter_D_scoring_fig.png')\n",
    "#plot2.fig.savefig('031725_engaged_commenter_A_scoring_fig.png')\n",
    "#plot3.fig.savefig('031725_engaged_commenter_V_scoring_fig.png')\n",
    "#plt.savefig('031625_engaged_commenter_VAD_scoring_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x150e3af81690>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1333.5x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n",
    "plot2.set_axis_labels(\"Index of Speaker's Comment\", \"Count of Polarized Words\")\n",
    "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot2.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot2.add_legend(title=\"Comment publication timestamp:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_19468/1559616732.py:4: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n",
      "  filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'resolved_dependency_relations_df' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[20], line 5\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m#pattern = r'\\b(WMF|Foundation)\\b'\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;66;03m#pattern = r'\\b(bots)\\b'\u001b[39;00m\n\u001b[1;32m      4\u001b[0m filtered_dependencies \u001b[38;5;241m=\u001b[39m dependency_relations_df[dependency_relations_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtoken\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(pattern, regex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)]\n\u001b[0;32m----> 5\u001b[0m resolved_filtered_dependencies \u001b[38;5;241m=\u001b[39m \u001b[43mresolved_dependency_relations_df\u001b[49m[resolved_dependency_relations_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtoken\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;241m.\u001b[39mstr\u001b[38;5;241m.\u001b[39mcontains(pattern, regex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)]\n\u001b[1;32m      7\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m12\u001b[39m, \u001b[38;5;241m8\u001b[39m))\n\u001b[1;32m      8\u001b[0m gs \u001b[38;5;241m=\u001b[39m GridSpec(\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m1\u001b[39m, height_ratios\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m6\u001b[39m, \u001b[38;5;241m6\u001b[39m])\n",
      "\u001b[0;31mNameError\u001b[0m: name 'resolved_dependency_relations_df' is not defined"
     ]
    }
   ],
   "source": [
    "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n",
    "#pattern = r'\\b(WMF|Foundation)\\b'\n",
    "#pattern = r'\\b(bots)\\b'\n",
    "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n",
    "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "gs = GridSpec(2, 1, height_ratios=[6, 6])\n",
    "\n",
    "# Main plot: Token depth by timestamp\n",
    "'''\n",
    "ax0 = plt.subplot(gs[0])\n",
    "sns.scatterplot(data=filtered_dependencies, x='timestamp', y='dependency', hue='wmfAffil', style='dependency', markers=True, s=100, ax=ax0)\n",
    "ax0.set_title('VE Depth by Timestamp w/o URLS')\n",
    "ax0.set_xlabel('')\n",
    "ax0.set_ylabel('Dependency Type')\n",
    "ax0.legend().set_visible(False)\n",
    "'''\n",
    "# Calculate the median depth over time\n",
    "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n",
    "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n",
    "wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n",
    "other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "# Plot the median depth over time\n",
    "ax0 = plt.subplot(gs[0])\n",
    "sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n",
    "sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n",
    "sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n",
    "ax0.set_title('Median Depth of \"VE\" in Phabricator Sentence Dependency Trees')\n",
    "ax0.set_ylabel('Median Depth')\n",
    "ax0.set_xlabel('')\n",
    "\n",
    "# Calculate the median depth over time\n",
    "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n",
    "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n",
    "resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n",
    "resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "# Plot the median depth over time\n",
    "ax1 = plt.subplot(gs[1])\n",
    "sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n",
    "sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n",
    "sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n",
    "ax1.set_title('Median Depth of \"VE\" in Coreference-resolved Phabricator Sentence Dependency Trees')\n",
    "ax1.set_ylabel('Median Depth')\n",
    "ax1.set_xlabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "#plt.show()\n",
    "\n",
    "#plt.savefig('031625_VE_depth_fig.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}