Statistics-TestGapRadar-public.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prioritization of Risky Test Gaps From Test Gap Reviews"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "import numpy as np\n",
    "import csv\n",
    "import ast\n",
    "from dataclasses import dataclass, fields\n",
    "from typing import Type, TypeVar\n",
    "from pathlib import Path\n",
    "from typing import Union, List, Optional, Dict\n",
    "from scipy import stats\n",
    "from sklearn import preprocessing\n",
    "from sklearn.metrics import r2_score\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from scipy.stats import shapiro\n",
    "import pingouin as pg\n",
    "import os\n",
    "\n",
    "alpha = 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = TypeVar('T', bound='GenericRecord')\n",
    "\n",
    "class GenericRecord:\n",
    "    \"\"\" Generic base class for transforming dataclasses. \"\"\"\n",
    "    @classmethod\n",
    "    def _transform(cls: Type[T], dict_: dict) -> dict:\n",
    "        \"\"\" Convert string values in given dictionary to corresponding type. \"\"\"\n",
    "        return {field.name: cls._transform_field(field, dict_[field.name])\n",
    "                    for field in fields(cls)}\n",
    "    \n",
    "    @classmethod\n",
    "    def _transform_field(cls: Type[T], field, value):\n",
    "        if field.type is float:\n",
    "            return float(value.replace(',', '.'))\n",
    "        return field.type(value)\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class CSV_Record(GenericRecord):\n",
    "    \"\"\" Define the fields and their types in a record.\n",
    "        Field names must match column names in CSV file header.\n",
    "    \"\"\"\n",
    "    project: str\n",
    "    month: str\n",
    "    test_gap_assessment: str\n",
    "    risk_score: float\n",
    "    score_LEN: float\n",
    "    score_COM: float\n",
    "    score_CLI: float\n",
    "    score_COC: float\n",
    "    score_ANF: float\n",
    "    score_UNF: float\n",
    "    score_RNF: float\n",
    "    score_ACF: float\n",
    "    score_UCF: float\n",
    "    score_RCF: float\n",
    "    score_CHF: float\n",
    "    score_CEN: float\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test_Gap:\n",
    "    def __init__(self, test_gap_assessment, risk_score):\n",
    "        self.test_gap_assessment = test_gap_assessment\n",
    "        self.risk_score = risk_score\n",
    "\n",
    "        if test_gap_assessment == \"risky\":\n",
    "            self.assessment_score = 1\n",
    "        elif test_gap_assessment == \"safe\":\n",
    "            self.assessment_score = 0\n",
    "        else:\n",
    "            self.assessment_score = -1\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'Test_Gap()'\n",
    "\n",
    "\n",
    "class Assessment:\n",
    "\n",
    "    def __init__(self, project, month, test_gaps):\n",
    "        self.project = project\n",
    "        self.month = month\n",
    "        self.test_gaps = test_gaps\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'Assessment({self.project}-{self.month})'\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_csv_and_get_test_gaps(filename):\n",
    "    records = []\n",
    "\n",
    "    with open(filename, 'r', newline='', encoding='latin') as file:\n",
    "        for i, row in enumerate(csv.DictReader(file, delimiter = ';', quoting=csv.QUOTE_MINIMAL)):\n",
    "            records.append(CSV_Record._transform(row))\n",
    "    \n",
    "    previous_project = \"\"\n",
    "    previous_month = \"\"\n",
    "    current_project = \"\"\n",
    "    current_month = \"\"\n",
    "\n",
    "    test_gaps_by_assessments = []\n",
    "\n",
    "    test_gaps_of_assessment = []\n",
    "\n",
    "    for record in records:\n",
    "        current_project = record[\"project\"]\n",
    "        current_month = record[\"month\"]\n",
    "        test_gap = Test_Gap(record[\"test_gap_assessment\"], record[\"risk_score\"])\n",
    "        if current_project == previous_project and current_month == previous_month:\n",
    "            test_gaps_of_assessment.append(test_gap)\n",
    "        else:\n",
    "            if previous_project != \"\":\n",
    "                test_gaps_by_assessments.append(Assessment(previous_project,previous_month,test_gaps_of_assessment))\n",
    "            previous_project=current_project\n",
    "            previous_month=current_month\n",
    "\n",
    "            test_gaps_of_assessment = []\n",
    "            test_gaps_of_assessment.append(test_gap)\n",
    "    test_gaps_by_assessments.append(Assessment(previous_project,previous_month,test_gaps_of_assessment))\n",
    "\n",
    "    return test_gaps_by_assessments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistics on Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_stats(test_gaps_by_assessments):\n",
    "    print('Total number of assessments: %.0f' % len(test_gaps_by_assessments))\n",
    "\n",
    "    risky_test_gaps = 0\n",
    "    safe_test_gaps = 0\n",
    "\n",
    "    relative_ranks_risky_gaps = []\n",
    "    relative_ranks_safe_gaps = []\n",
    "\n",
    "    project_test_gaps = {}\n",
    "    project_risky_test_gaps = {}\n",
    "    project_assessments = {}\n",
    "\n",
    "    for assessment in test_gaps_by_assessments:\n",
    "        for test_gap in assessment.test_gaps:\n",
    "            if test_gap.test_gap_assessment == \"risky\":\n",
    "                risky_test_gaps += 1\n",
    "            elif test_gap.test_gap_assessment == \"safe\":\n",
    "                safe_test_gaps += 1\n",
    "            else:\n",
    "                raise ValueError('The test_gap_assessment must be either \\'risky\\' or \\'safe\\' but was', test_gap[\"test_gao_assessment\"])\n",
    "    \n",
    "    total_test_gaps = risky_test_gaps+safe_test_gaps\n",
    "    print('Total number of test gaps: %.0f' % total_test_gaps)\n",
    "    print('Safe test gaps: %.0f' % safe_test_gaps)\n",
    "    print('Risky test gaps: %.0f' % risky_test_gaps)\n",
    "    scaled_risky_ranks = []\n",
    "    scaled_safe_ranks = []\n",
    "    \n",
    "    assessment_scores = []\n",
    "    all_risk_scores = []\n",
    "    \n",
    "    for assessment in test_gaps_by_assessments:\n",
    "    \n",
    "        number_of_risky_gaps = 0\n",
    "        number_of_gaps = len(assessment.test_gaps)\n",
    "        assessment_risk_scores = []\n",
    "        ranks_risky_gaps = []\n",
    "        ranks_safe_gaps = []\n",
    "        \n",
    "        for test_gap in assessment.test_gaps:\n",
    "            assessment_scores.append(test_gap.assessment_score)\n",
    "            all_risk_scores.append(test_gap.risk_score)\n",
    "            assessment_risk_scores.append(test_gap.risk_score)\n",
    "            number_of_risky_gaps += test_gap.assessment_score\n",
    "    \n",
    "        number_of_safe_gaps = number_of_gaps - number_of_risky_gaps\n",
    "        \n",
    "        ranks = stats.rankdata(np.array(assessment_risk_scores) * -1 ) # ranking assumes lowest number to be best => multiply by  -1\n",
    "        zipped = dict(zip(assessment_risk_scores, ranks))\n",
    "\n",
    "        if assessment.project in project_test_gaps:\n",
    "            project_test_gaps[assessment.project] = project_test_gaps[assessment.project] + number_of_gaps\n",
    "            project_risky_test_gaps[assessment.project] = project_risky_test_gaps[assessment.project] + number_of_risky_gaps\n",
    "            project_assessments[assessment.project] = project_assessments[assessment.project] + 1\n",
    "        else:\n",
    "            project_test_gaps[assessment.project] = number_of_gaps\n",
    "            project_risky_test_gaps[assessment.project] = number_of_risky_gaps\n",
    "            project_assessments[assessment.project] = 1\n",
    "            \n",
    "    \n",
    "        for test_gap in assessment.test_gaps:\n",
    "            if test_gap.assessment_score == 1:\n",
    "                ranks_risky_gaps.append(zipped[test_gap.risk_score])\n",
    "                relative_ranks_risky_gaps.append((zipped[test_gap.risk_score]-1)/(number_of_gaps-1))\n",
    "            else:\n",
    "                ranks_safe_gaps.append(zipped[test_gap.risk_score])\n",
    "                relative_ranks_safe_gaps.append((zipped[test_gap.risk_score]-1)/(number_of_gaps-1))\n",
    "        \n",
    "        if( number_of_risky_gaps == 0):\n",
    "            scaled_risky_rank = 1.0\n",
    "        elif(number_of_safe_gaps == 0):\n",
    "            scaled_risky_rank = 0.0\n",
    "        else:\n",
    "            best_possible_ranking = (number_of_risky_gaps * (number_of_risky_gaps + 1)) / (2 * number_of_risky_gaps * number_of_gaps)\n",
    "            worst_possible_ranking = - (number_of_risky_gaps - 2 * number_of_gaps - 1) / (2 * number_of_gaps)\n",
    "        \n",
    "            sum_ranks_risky_gaps = sum(ranks_risky_gaps)\n",
    "            scaled_risky_rank = (( sum_ranks_risky_gaps / (number_of_risky_gaps * ( number_of_gaps))) - best_possible_ranking) / (worst_possible_ranking - best_possible_ranking) # min-max scaling\n",
    "        \n",
    "        scaled_risky_ranks.append(scaled_risky_rank)\n",
    "    \n",
    "        if( number_of_safe_gaps == 0):\n",
    "            scaled_safe_rank = 0.0\n",
    "        elif(number_of_risky_gaps == 0):\n",
    "            scaled_safe_rank = 1.0\n",
    "        else:\n",
    "            best_possible_ranking = (number_of_safe_gaps * (number_of_safe_gaps + 1)) / (2 * number_of_safe_gaps * number_of_gaps)\n",
    "            worst_possible_ranking = - (number_of_safe_gaps - 2 * number_of_gaps - 1) / (2 * number_of_gaps)\n",
    "            sum_ranks_safe_gaps = sum(ranks_safe_gaps)\n",
    "            scaled_safe_rank = (( sum_ranks_safe_gaps / (number_of_safe_gaps * ( number_of_gaps))) - best_possible_ranking) / (worst_possible_ranking - best_possible_ranking) # min-max scaling\n",
    "        scaled_safe_ranks.append(scaled_safe_rank)\n",
    "    \n",
    "    return scaled_risky_ranks, scaled_safe_ranks, relative_ranks_risky_gaps, relative_ranks_safe_gaps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistical Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_kendall_and_u(test_gaps_by_assessments):\n",
    "    scaled_risky_ranks = []\n",
    "    scaled_safe_ranks = []\n",
    "\n",
    "    assessment_scores = []\n",
    "    all_risk_scores = []\n",
    "\n",
    "    for assessment in test_gaps_by_assessments:\n",
    "\n",
    "        number_of_risky_gaps = 0\n",
    "        number_of_gaps = len(assessment.test_gaps)\n",
    "        assessment_risk_scores = []\n",
    "        ranks_risky_gaps = []\n",
    "        ranks_safe_gaps = []\n",
    "\n",
    "        for test_gap in assessment.test_gaps:\n",
    "            assessment_scores.append(test_gap.assessment_score)\n",
    "            all_risk_scores.append(test_gap.risk_score)\n",
    "            assessment_risk_scores.append(test_gap.risk_score)\n",
    "            number_of_risky_gaps += test_gap.assessment_score\n",
    "\n",
    "        number_of_safe_gaps = number_of_gaps - number_of_risky_gaps\n",
    "\n",
    "        ranks = stats.rankdata(np.array(assessment_risk_scores) * -1 ) # ranking assumes lowest number to be best => multiply by  -1\n",
    "        zipped = dict(zip(assessment_risk_scores, ranks))\n",
    "\n",
    "        for test_gap in assessment.test_gaps:\n",
    "            if test_gap.assessment_score == 1:\n",
    "                ranks_risky_gaps.append(zipped[test_gap.risk_score])\n",
    "            else:\n",
    "                ranks_safe_gaps.append(zipped[test_gap.risk_score])\n",
    "\n",
    "        if( number_of_risky_gaps == 0):\n",
    "            scaled_risky_rank = 1.0\n",
    "        elif(number_of_safe_gaps == 0):\n",
    "            scaled_risky_rank = 0.0\n",
    "        else:\n",
    "            best_possible_ranking = (number_of_risky_gaps * (number_of_risky_gaps + 1)) / (2 * number_of_risky_gaps * number_of_gaps)\n",
    "            worst_possible_ranking = - (number_of_risky_gaps - 2 * number_of_gaps - 1) / (2 * number_of_gaps)\n",
    "\n",
    "            sum_ranks_risky_gaps = sum(ranks_risky_gaps)\n",
    "            scaled_risky_rank = (( sum_ranks_risky_gaps / (number_of_risky_gaps * ( number_of_gaps))) - best_possible_ranking) / (worst_possible_ranking - best_possible_ranking) # min-max scaling\n",
    "        scaled_risky_ranks.append(scaled_risky_rank)\n",
    "\n",
    "        if( number_of_safe_gaps == 0):\n",
    "            scaled_safe_rank = 0.0\n",
    "        elif(number_of_risky_gaps == 0):\n",
    "            scaled_safe_rank = 1.0\n",
    "        else:\n",
    "            best_possible_ranking = (number_of_safe_gaps * (number_of_safe_gaps + 1)) / (2 * number_of_safe_gaps * number_of_gaps)\n",
    "            worst_possible_ranking = - (number_of_safe_gaps - 2 * number_of_gaps - 1) / (2 * number_of_gaps)\n",
    "            sum_ranks_safe_gaps = sum(ranks_safe_gaps)\n",
    "            scaled_safe_rank = (( sum_ranks_safe_gaps / (number_of_safe_gaps * ( number_of_gaps))) - best_possible_ranking) / (worst_possible_ranking - best_possible_ranking) # min-max scaling\n",
    "        scaled_safe_ranks.append(scaled_safe_rank)\n",
    "\n",
    "    res = stats.kendalltau(assessment_scores, all_risk_scores)\n",
    "    kendall_score = res.statistic\n",
    "    kendall_p = res.pvalue\n",
    "\n",
    "\n",
    "    res = stats.mannwhitneyu(scaled_risky_ranks, scaled_safe_ranks, alternative = 'less')\n",
    "    mannwhitneyu_score = res.statistic\n",
    "    mannwhitneyu_p = res.pvalue\n",
    "\n",
    "    print('-----')\n",
    "    print('Kendall\\'s tau statistic: %.3f' % kendall_score)\n",
    "    print('Kendall\\'s tau p-value: %.3f' % kendall_p)\n",
    "\n",
    "\n",
    "    print('U-test\\'s statistic: %.3f' % mannwhitneyu_score)\n",
    "    print('U-test\\'s p-value: %.3f' % mannwhitneyu_p)\n",
    "    # conclusion \n",
    "    if np.average(mannwhitneyu_p) < alpha: \n",
    "        print('Reject Null Hypothesis (Significant difference between two samples)') \n",
    "    else: \n",
    "        print('Do not Reject Null Hypothesis (No significant difference between two samples)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# From https://gist.github.com/ihincks/6a420b599f43fcd7dbd79d56798c4e5a#file-lighten_color-py\n",
    "def lighten_color(color, amount=0.5):\n",
    "    \"\"\"\n",
    "    Lightens the given color by multiplying (1-luminosity) by the given amount.\n",
    "    Input can be matplotlib color string, hex string, or RGB tuple.\n",
    "\n",
    "    Examples:\n",
    "    >> lighten_color('g', 0.3)\n",
    "    >> lighten_color('#F034A3', 0.6)\n",
    "    >> lighten_color((.3,.55,.1), 0.5)\n",
    "    \"\"\"\n",
    "    import matplotlib.colors as mc\n",
    "    import colorsys\n",
    "    try:\n",
    "        c = mc.cnames[color]\n",
    "    except:\n",
    "        c = color\n",
    "    c = colorsys.rgb_to_hls(*mc.to_rgb(c))\n",
    "    return colorsys.hls_to_rgb(c[0], max(0, min(1, amount * c[1])), c[2])\n",
    "\n",
    "\n",
    "def draw_agreement_kdp(scaled_risky_ranks):\n",
    "    sns.set(style=\"whitegrid\")\n",
    "\n",
    "    colors = sns.color_palette('Set1')\n",
    "\n",
    "    risky_color = lighten_color(colors[2], 1.3)\n",
    "    \n",
    "    plt.figure(figsize=(8,4))\n",
    "\n",
    "    ax = sns.histplot({'Risky': scaled_risky_ranks}, kde=True,\n",
    "                      kde_kws={'bw_adjust': 0.4},\n",
    "                      line_kws={'lw': 2},\n",
    "                      multiple='layer', binwidth=0.1,  \n",
    "                      palette={'Risky': risky_color})\n",
    "\n",
    "    median_risky = np.median(scaled_risky_ranks)\n",
    "    \n",
    "    # Add median line\n",
    "    plt.axvline(median_risky, color=risky_color, linestyle='--', linewidth=2) \n",
    "    \n",
    "    # Create legend patch\n",
    "    patch1 = mpatches.Patch(color=risky_color, label=f'$v$ of test gap reviews\\n(median: {median_risky:.2f})')\n",
    "    plt.legend(handles=[patch1], fontsize=20)\n",
    "\n",
    "    ax.yaxis.set_major_locator(MaxNLocator(integer=True))\n",
    "\n",
    "    plt.xlabel('Agreement values $v$', fontsize=20) \n",
    "    plt.ylabel('Density', fontsize=20) \n",
    "    plt.xticks(fontsize=18)\n",
    "    plt.yticks(fontsize=18)\n",
    "\n",
    "    # Add annotations for best and worst\n",
    "    ax.annotate('Optimal\\nagreement', xy=(0.045, -0.25), xycoords='axes fraction', ha='center', va='center', fontsize=18)\n",
    "    ax.annotate('No\\nagreement', xy=(0.95, -0.25), xycoords='axes fraction', ha='center', va='center', fontsize=18)\n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "\n",
    "def draw_ranking_kdp(relative_ranks_risky_gaps,relative_ranks_safe_gaps):\n",
    "    \n",
    "    sns.set(style=\"whitegrid\")\n",
    "\n",
    "    colors = sns.color_palette('Set1')\n",
    "\n",
    "    risky_color = lighten_color(colors[0], 1.3)\n",
    "    safe_color = lighten_color(colors[1], 0.7)\n",
    "\n",
    "    plt.figure(figsize=(8,4))\n",
    "\n",
    "    ax = sns.histplot({'Risky': relative_ranks_risky_gaps, 'Safe': relative_ranks_safe_gaps}, kde=True,\n",
    "                      kde_kws={'bw_adjust': 0.4},\n",
    "                      line_kws={'lw': 2},\n",
    "                      multiple='layer', binwidth=0.1,  \n",
    "                      palette={'Risky': risky_color, 'Safe': safe_color})\n",
    "\n",
    "    median_risky = np.median(relative_ranks_risky_gaps)\n",
    "    median_safe = np.median(relative_ranks_safe_gaps)\n",
    "\n",
    "    # Add median lines\n",
    "    plt.axvline(median_risky, color=risky_color, linestyle='--', linewidth=2) \n",
    "    plt.axvline(median_safe, color=safe_color, linestyle='--', linewidth=2) \n",
    "\n",
    "    # Create legend patches\n",
    "    patch1 = mpatches.Patch(color=risky_color, label=f'Risky (median: {median_risky:.2f})')\n",
    "    patch2 = mpatches.Patch(color=safe_color, label=f'Less risky (median: {median_safe:.2f})')\n",
    "    plt.legend(handles=[patch1, patch2], fontsize=20)\n",
    "\n",
    "    ax.yaxis.set_major_locator(MaxNLocator(integer=True))\n",
    "\n",
    "    plt.xlabel(r'Relative rankings $\\bar{R}$ of test gaps', fontsize=20) \n",
    "    plt.ylabel('Density', fontsize=20) \n",
    "    plt.xticks(fontsize=18)\n",
    "    plt.yticks(fontsize=18)\n",
    "\n",
    "    # Add annotations for best and worst\n",
    "    ax.annotate('Best\\nrank', xy=(0.045, -0.25), xycoords='axes fraction', ha='center', va='center', fontsize=18)\n",
    "    ax.annotate('Worst\\nrank', xy=(0.95, -0.25), xycoords='axes fraction', ha='center', va='center', fontsize=18)\n",
    "\n",
    "    #plt.title('Kernel Density Plot of Test Gap Ranks', fontsize=14) \n",
    "\n",
    "    plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis for all Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.Assessment at 0x295002df950>,\n",
       " <__main__.Assessment at 0x295002dfed0>,\n",
       " <__main__.Assessment at 0x295002ec410>,\n",
       " <__main__.Assessment at 0x295002ec790>,\n",
       " <__main__.Assessment at 0x295002ec890>,\n",
       " <__main__.Assessment at 0x295002ecd50>,\n",
       " <__main__.Assessment at 0x295002ed150>,\n",
       " <__main__.Assessment at 0x295002ed310>,\n",
       " <__main__.Assessment at 0x295002ed450>,\n",
       " <__main__.Assessment at 0x295002ed610>,\n",
       " <__main__.Assessment at 0x295002eda90>,\n",
       " <__main__.Assessment at 0x295002edc90>,\n",
       " <__main__.Assessment at 0x295002ee6d0>,\n",
       " <__main__.Assessment at 0x295002eed10>,\n",
       " <__main__.Assessment at 0x295002eee50>,\n",
       " <__main__.Assessment at 0x295002eef50>,\n",
       " <__main__.Assessment at 0x295002ef310>,\n",
       " <__main__.Assessment at 0x295002ef990>,\n",
       " <__main__.Assessment at 0x295002efe10>,\n",
       " <__main__.Assessment at 0x295002f0590>,\n",
       " <__main__.Assessment at 0x295002f0f50>,\n",
       " <__main__.Assessment at 0x295002f1250>,\n",
       " <__main__.Assessment at 0x295002f1990>,\n",
       " <__main__.Assessment at 0x295002f8a10>,\n",
       " <__main__.Assessment at 0x295002fa810>,\n",
       " <__main__.Assessment at 0x295002fb810>,\n",
       " <__main__.Assessment at 0x29500302ad0>,\n",
       " <__main__.Assessment at 0x29500314110>,\n",
       " <__main__.Assessment at 0x2950031c290>,\n",
       " <__main__.Assessment at 0x2950031c490>,\n",
       " <__main__.Assessment at 0x2950031c690>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "notebook_path = os.path.abspath(\"Statistics-TestGapRadar-public.ipynb\")\n",
    "p = os.path.join(os.path.dirname(notebook_path), \"reviews-public-data.csv\")\n",
    "\n",
    "test_gaps_by_assessments = read_csv_and_get_test_gaps(p)\n",
    "test_gaps_by_assessments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of assessments: 31\n",
      "Total number of test gaps: 2039\n",
      "Safe test gaps: 1858\n",
      "Risky test gaps: 181\n"
     ]
    }
   ],
   "source": [
    "scaled_risky_ranks, scaled_safe_ranks, relative_ranks_risky_gaps, relative_ranks_safe_gaps = print_stats(test_gaps_by_assessments)\n",
    "scaled_risky_ranks_all = scaled_risky_ranks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----\n",
      "Kendall's tau statistic: 0.289\n",
      "Kendall's tau p-value: 0.000\n",
      "U-test's statistic: 127.500\n",
      "U-test's p-value: 0.000\n",
      "Reject Null Hypothesis (Significant difference between two samples)\n"
     ]
    }
   ],
   "source": [
    "print_kendall_and_u(test_gaps_by_assessments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_agreement_kdp(scaled_risky_ranks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_ranking_kdp(relative_ranks_risky_gaps,relative_ranks_safe_gaps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}