mw-lifecycle-analysis/text_analysis/case2/.ipynb_checkpoints/040425_phab_comments-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "ba9e5acd-e17d-4318-9272-04c9f6706186",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import spacy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "e4f0b3f0-5255-46f1-822f-e455087ba315",
   "metadata": {},
   "outputs": [],
   "source": [
    "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case2/0402_https1_phab_comments.csv\"\n",
    "phab_df = pd.read_csv(phab_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "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\"):\n",
    "                return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "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": 100,
   "id": "d449164e-1d28-4580-9eb1-f0f69978f114",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/2662409405.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_13098/2662409405.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 12-1-2012 before 12-1-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'] < 1385856000) & (phab_df['date_created'] > 1354320000)]\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": 101,
   "id": "942344db-c8f5-4ed6-a757-c97f8454f18b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique conversation_ids: 382\n",
      "Unique ids: 1838\n",
      "Unique speakers: 189\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": 102,
   "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": 103,
   "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/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": 104,
   "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": 105,
   "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/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": 107,
   "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": 108,
   "id": "828fb57a-e152-42ef-9c60-660648898532",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/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_13098/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_13098/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_13098/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": 109,
   "id": "27e47f6f-0257-4b70-b222-e91ef888c900",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/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_13098/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_13098/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": 110,
   "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": 39,
   "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": 111,
   "id": "82cd9dde-0d14-4de5-8482-5a39de8d2869",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/1702682277.py:7: 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",
    "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",
    "\n",
    "#plt.savefig('031825_new_tasks_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "9a9b08a7-6c95-4971-b259-8e713c58fbe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/3506948764.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_13098/3506948764.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_13098/3506948764.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_13098/3506948764.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 09-30-2013\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df[(unaff_tasks_phab_df['date_created'] < 1380499200) & (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 09-30-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 06-01-2013 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": 113,
   "id": "b7cfad77-d48a-4708-91f3-89ae1179b90c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_13098/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_13098/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_13098/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_13098/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                      565\n",
      "After announcement, before deployment    297\n",
      "After deployment                         976\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group:\n",
      "date_group\n",
      "Before announcement                      100\n",
      "After announcement, before deployment     71\n",
      "After deployment                         143\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         549\n",
      "                                                      True           16\n",
      "After announcement, before deployment  False          False         284\n",
      "                                                      True           13\n",
      "After deployment                       False          False         953\n",
      "                                                      True           23\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          99\n",
      "                                                      True            6\n",
      "After announcement, before deployment  False          False          70\n",
      "                                                      True            8\n",
      "After deployment                       False          False         139\n",
      "                                                      True           14\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         1786\n",
      "               True            52\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         184\n",
      "               True           23\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": 113,
     "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": [
    "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": 35,
   "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x14ca72b957f0>"
      ]
     },
     "execution_count": 35,
     "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}