generating_results.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import polars as pl\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "import numpy as np\n",
    "pd.set_option('display.max_columns', 200)\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import re\n",
    "import csv\n",
    "import os\n",
    "import re\n",
    "import itertools\n",
    "from collections import Counter\n",
    "from fpdf import FPDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_method_name(signature):\n",
    "    method_full_name = signature.split('(')[0]\n",
    "    method_name = method_full_name.split('.')[-1]\n",
    "    return method_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files merged successfully! File saved as 'merged_file.csv'.\n"
     ]
    }
   ],
   "source": [
    "# Name of the CSV file\n",
    "file_name = 'revList.csv'\n",
    "\n",
    "# List to store the DataFrames\n",
    "found_files = []\n",
    "\n",
    "# Open the CSV file for reading\n",
    "with open(file_name, mode='r', newline='', encoding='utf-8') as file:\n",
    "    # Create a CSV reader\n",
    "    csv_reader = csv.reader(file, delimiter=';')\n",
    "    \n",
    "    # Skip the first line (header)\n",
    "    next(csv_reader)\n",
    "    \n",
    "    # Read the remaining lines and process each line\n",
    "    for row in csv_reader:\n",
    "        project = row[0]\n",
    "        merge_commit = row[1]\n",
    "        class_name = row[2]\n",
    "        method = row[3]\n",
    "        # left_modification = row[4]\n",
    "        # has_build = row[5]\n",
    "        # left_deletion = row[6]\n",
    "        # right_modification = row[7]\n",
    "        # right_deletion = row[8]\n",
    "        # realistic_case_path = row[9]\n",
    "\n",
    "        # Generate path\n",
    "        parts = class_name.split('.')\n",
    "        class_name = parts.pop()\n",
    "        class_path = '.'.join(parts).replace(\".\", \"/\")\n",
    "        method_name = extract_method_name(method)\n",
    "\t\t\n",
    "        path_file = f\"joana/reports/{project}/{merge_commit}/{class_path}/{class_name}/{method_name}/executionSummary.csv\"\n",
    "        \n",
    "        if os.path.exists(path_file):\n",
    "            try:\n",
    "                df = pd.read_csv(path_file, sep=';')\n",
    "                # Add context columns to the DataFrame\n",
    "                df['project'] = project\n",
    "                df['merge commit'] = merge_commit\n",
    "                df['class'] = class_name\n",
    "                df['original method'] = method\n",
    "\n",
    "            except:\n",
    "                print(f\"Error: The file '{path_file}' is empty.\")\n",
    "                data = {\n",
    "                'project': project,\n",
    "                'merge commit': merge_commit,\n",
    "                'class': class_name,\n",
    "                'original method': [method]\n",
    "                }\n",
    "                \n",
    "                df = pd.DataFrame(data)\n",
    "\n",
    "        else:\n",
    "\n",
    "            data = {\n",
    "                'project': project,\n",
    "                'merge commit': merge_commit,\n",
    "                'class': class_name,\n",
    "                'original method': [method]\n",
    "            }\n",
    "            \n",
    "            df = pd.DataFrame(data)\n",
    "\n",
    "        # Reorder columns to have new columns at the beginning\n",
    "        columns_order = ['project', 'merge commit', 'class', 'original method'] + [col for col in df.columns if col not in ['project', 'merge commit', 'class', 'original method']]\n",
    "        df = df[columns_order]\n",
    "        found_files.append(df)\n",
    "\n",
    "    \n",
    "    # Check if there are DataFrames to concatenate\n",
    "    if len(found_files) > 0:\n",
    "        # Concatenate all DataFrames, keeping all rows and columns\n",
    "        merged_file = pd.concat(found_files, ignore_index=True, sort=False)\n",
    "\n",
    "        merged_file = merged_file.drop(columns=['Method'])\n",
    "\n",
    "        # Save the result to a new CSV file with ';' as separator\n",
    "        merged_file.to_csv('merged_file.csv', index=False, sep=';')\n",
    "        print(\"Files merged successfully! File saved as 'merged_file.csv'.\")\n",
    "    else:\n",
    "        print(\"No file was found!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading analyses execution results...\n",
      "Generating results...\n",
      "Results in results.pdf\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.ReportAnalysis at 0x102f5b820>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class ReportAnalysis:\n",
    "\n",
    "    def __init__(self, path_result, path_ground_truth):\n",
    "        self.soot_results = pd.read_csv(path_result, sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "        self.loi = pd.read_csv(path_ground_truth, sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "\n",
    "        self.generate_results()\n",
    "\n",
    "    def get_method_name(self, method_declaration):\n",
    "        match = re.search(r'\\.([a-zA-Z_][a-zA-Z0-9_]*)\\(', method_declaration)\n",
    "        if match:\n",
    "            method_name = match.group(1)\n",
    "            print(\"Method name:\", method_name)\n",
    "        else:\n",
    "            print(\"Method name not found.\")\n",
    "\n",
    "    def get_loi(self, project, class_name,  method, merge_commit):\n",
    "        df = pd.read_csv(\"LOI.csv\", delimiter=';')\n",
    "    \n",
    "        # Encontrar o índice do ponto final e do parêntese\n",
    "        dot_index = method.rfind('.')\n",
    "        paren_index = method.find('(')\n",
    "\n",
    "        method_name = \"\"\n",
    "\n",
    "        # Extrair o nome do método\n",
    "        if dot_index != -1 and paren_index != -1:\n",
    "            method_name = method[dot_index + 1:paren_index]\n",
    "\n",
    "        value_LOI = (\"\", \"\")\n",
    "        \n",
    "        for project_l, class_name_l, method_l, merge_commit_l, LOI, original_sample in zip(\n",
    "            df['Project'], \n",
    "            df['Class Name'], \n",
    "            df['Method or field declaration changed by the two merged branches'], \n",
    "            df['Merge Commit'], \n",
    "            df['Locally Observable Interference'],\n",
    "            df['Original Sample'],\n",
    "        ):\n",
    "            if (project_l == project and \n",
    "                class_name in class_name_l  and \n",
    "                method_name in method_l and \n",
    "                merge_commit_l == merge_commit):\n",
    "                \n",
    "                value_LOI = (LOI, original_sample)\n",
    "\n",
    "                break  # Para parar no primeiro match encontrado\n",
    "\n",
    "        return value_LOI\n",
    "\n",
    "    def calculate_matrix_loi(self, columns):\n",
    "        results = []\n",
    "        loi_list = []\n",
    "        original_sample_list = []\n",
    "        info_LOI = ['project', 'class', 'original method', 'merge commit']\n",
    "        \n",
    "        # Limpar espaços em branco nos nomes das colunas\n",
    "        self.soot_results.columns = self.soot_results.columns.str.strip()\n",
    "\n",
    "        for index, row in self.soot_results.iterrows():\n",
    "            value = row['HasSourcedAndSink']\n",
    "                    \n",
    "            values_LOI = [row[column] for column in info_LOI if column in row]\n",
    "\n",
    "            (loi_actual, original_sample) = self.get_loi(*values_LOI)\n",
    "            \n",
    "            loi_list.append(loi_actual)\n",
    "            original_sample_list.append(original_sample)\n",
    "\n",
    "            result = \"-\"\n",
    "            # Determinar o resultado\n",
    "            if \"Yes\" in str(value) and \"Yes\" in loi_actual:\n",
    "                result = \"TRUE POSITIVE\"\n",
    "            elif \"No\" in str(value) and \"No\" in loi_actual:\n",
    "                result = \"TRUE NEGATIVE\"\n",
    "            elif \"No\" in str(value) and \"Yes\" in loi_actual:\n",
    "                result = \"FALSE NEGATIVE\"\n",
    "            elif \"Yes\" in str(value) and \"No\" in loi_actual:\n",
    "                result = \"FALSE POSITIVE\"\n",
    "            \n",
    "            results.append(result)\n",
    "            \n",
    "        df = pd.read_csv('merged_file.csv', sep=';')\n",
    "        df['LOI'] = loi_list\n",
    "        df['Original Sample'] = original_sample_list\n",
    "        df['result'] = results\n",
    "\n",
    "        # Salvar o novo DataFrame em um novo arquivo CSV\n",
    "        new_csv_path = 'results.csv'\n",
    "        df.to_csv(new_csv_path, sep=';', index=False)\n",
    "\n",
    "        return results\n",
    "\n",
    "    def generate_results(self):\n",
    "\n",
    "        print(\"Generating results...\")\n",
    "\n",
    "        FP,TP, FN, TN = 0, 0, 0, 0\n",
    "\n",
    "        list_columns = self.soot_results.columns.tolist()\n",
    "\n",
    "        result_matrix = self.calculate_matrix_loi(list_columns)\n",
    "\n",
    "        for elem, count in Counter(result_matrix).items():\n",
    "            if (elem == 'FALSE POSITIVE'):\n",
    "                FP = count\n",
    "            if (elem == 'FALSE NEGATIVE'):\n",
    "                FN = count\n",
    "            if (elem == 'TRUE POSITIVE'):\n",
    "                TP = count\n",
    "            if (elem == 'TRUE NEGATIVE'):\n",
    "                TN = count\n",
    "\n",
    "        sensitivity = 0 if ((TP + FN) == 0) else (TP / (TP + FN))\n",
    "        precision = 0 if ((TP + FP) == 0) else (TP / (TP + FP))\n",
    "        f1_score = 0 if ((2*TP + FP + FN) == 0) else (2*TP / (2*TP + FP + FN))\n",
    "        accuracy = 0 if ((FP + TP + TN + FN) == 0) else ((TP + TN) / (FP + TP + TN + FN))\n",
    "\n",
    "        df = pd.read_csv(\"results.csv\", sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "       \n",
    "        fail_results = df['result'].eq(\"-\").sum()\n",
    "        total = len(df)\n",
    "\n",
    "        # variable pdf\n",
    "        pdf = FPDF()\n",
    "\n",
    "        # add a page\n",
    "        pdf.add_page()\n",
    "\n",
    "        # set style and size of font\n",
    "        # that you want in the pdf\n",
    "        pdf.set_font(\"Arial\", size = 15)\n",
    "\n",
    "        # create a cell\n",
    "        pdf.cell(200, 10, txt = \"Results for execution\",\n",
    "                 ln = 1, align = 'C')\n",
    "    \n",
    "        pdf.cell(200, 10, txt = (\"Precision: \"+str(round(precision, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"Recall: \"+str(round(sensitivity, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"F1 Score: \"+str(round(f1_score, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"Accuracy: \"+str(round(accuracy, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"False Positives: \"+str(FP)),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"False Negatives: \"+str(FN)),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"True Positives: \"+str(TP)),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"True Negatives: \"+str(TN)),\n",
    "                 ln = 2, align = 'L')\n",
    "        \n",
    "        pdf.cell(200, 10, txt = (f\"Total produzed: {total-fail_results} out of {total} units\"),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        cm = np.array([[TP,  FP], [FN, TN]])\n",
    "        normalize = False\n",
    "        target_names = ['Actually Positive', ' Actually Negative']\n",
    "        target_names2 = ['Predicted Positive', ' Predicted Negative']\n",
    "        title = \"Confusion Matrix\"\n",
    "\n",
    "        cmap = plt.get_cmap('Blues')\n",
    "\n",
    "        plt.figure(figsize=(8, 6))\n",
    "        plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "        plt.title(title, fontsize=16)\n",
    "        plt.colorbar()\n",
    "\n",
    "        if target_names is not None:\n",
    "            tick_marks = np.arange(len(target_names))\n",
    "            plt.xticks(tick_marks, target_names, fontsize=16)\n",
    "            plt.yticks(tick_marks, target_names2, fontsize=16)\n",
    "\n",
    "        if normalize:\n",
    "            cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "        thresh = cm.max() / 1.5 if normalize else cm.max() / 2\n",
    "        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "            if normalize:\n",
    "                plt.text(j, i, \"{:0.4f}\".format(cm[i, j]),\n",
    "                         horizontalalignment=\"center\",\n",
    "                         color=\"yellow\" if cm[i, j] > thresh else \"black\", fontsize=23)\n",
    "            else:\n",
    "                plt.text(j, i, \"{:,}\".format(cm[i, j]),\n",
    "                         horizontalalignment=\"center\",\n",
    "                         color=\"yellow\" if cm[i, j] > thresh else \"black\", fontsize=23)\n",
    "        plt.tight_layout()\n",
    "\n",
    "        plt.savefig(\"confusion_matrix.jpg\")\n",
    "\n",
    "        pdf.image(\"confusion_matrix.jpg\", x = None, y = None, w = 160, h = 110, type = 'jpg', link = 'confusion_matrix.jpg')\n",
    "\n",
    "        # Save the pdf with name .pdf\n",
    "        pdf.output(\"results.pdf\")\n",
    "        # pdf.output(\"results.pdf\")\n",
    "\n",
    "        print(\"Results in results.pdf\")\n",
    "\n",
    "path_ground_truth = \"LOI.csv\"\n",
    "path_result = 'merged_file.csv'\n",
    "\n",
    "print(\"Reading analyses execution results...\")\n",
    "\n",
    "ReportAnalysis(path_result, path_ground_truth)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading analyses execution results...\n",
      "[21225.594, 75.029, 26473.144, 26473.144, 84.263, 471.651, 471.651, 88.715, 11905.275, 16535.954, 165.137, 3189.842, 106.058, 87.6, 38023.636, 797.62, 2379.908, 424.773, 93.455, 89.749, 20487.314, 385.543, 15580.47, 60318.441, 111765.866, 93.723, 98.909, 98.909, 3122.767, 3371.422, 2959.638, 3486.014, 89.181, 87.706, 100.632, 100.632, 100.632, 5847.506, 8719.294, 5607.984, 93.889, 54295.213, 1341.476, 91.986, 2122.064, 87.11, 92.788, 376.298, 241.083]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "path_result = 'merged_file.csv'\n",
    "\n",
    "print(\"Reading analyses execution results...\")\n",
    "soot_results = pd.read_csv(path_result, sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "\n",
    "soot_results.columns = soot_results.columns.str.strip()\n",
    "list_time_seconds = []\n",
    "\n",
    "for index, row in soot_results.iterrows():\n",
    "    value = row['Time (ms)']\n",
    "    try:\n",
    "        # Ignora valores que não são numéricos, como ' -'\n",
    "        if str(value) not in ['', '-', 'NaN', 'nan']:\n",
    "            list_time_seconds.append(float(value) / 1000)\n",
    "    except ValueError:\n",
    "        continue\n",
    "       \n",
    "print(list_time_seconds)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# Exemplo de classe que utiliza a função plot_by_variable\n",
    "class Plotter:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def plot_by_variable(self, leg1, leg_x, time_list1):\n",
    "        # Define o tamanho da figura\n",
    "        fig, ax = plt.subplots(figsize=(10, 4))\n",
    "\n",
    "        # Dados\n",
    "        data_x = [time_list1]\n",
    "\n",
    "        # Cores para os gráficos\n",
    "        boxplot_color = 'yellowgreen'\n",
    "        violin_color = 'thistle'\n",
    "        scatter_color = 'tomato'\n",
    "\n",
    "        # Boxplot\n",
    "        bp = ax.boxplot(data_x, patch_artist=True, vert=False, positions=[1], widths=0.6)\n",
    "        for patch in bp['boxes']:\n",
    "            patch.set_facecolor(boxplot_color)\n",
    "            patch.set_alpha(0.4)\n",
    "\n",
    "        # Violinplot\n",
    "        vp = ax.violinplot(data_x, points=500, showmeans=True, showextrema=True, showmedians=False, vert=False)\n",
    "        for b in vp['bodies']:\n",
    "            b.set_color(violin_color)\n",
    "            b.set_alpha(0.6)\n",
    "\n",
    "        # Scatterplot\n",
    "        features = data_x[0]\n",
    "        y = np.full(len(features), 1)  # Usando apenas 1 para a posição no eixo Y\n",
    "        jitter = np.random.uniform(low=-0.1, high=0.1, size=len(features))\n",
    "        ax.scatter(features + jitter, y, s=15, c=scatter_color, alpha=0.7, edgecolor='k')\n",
    "\n",
    "        # Configurações do gráfico\n",
    "        ax.set_yticks([1])\n",
    "        ax.grid(False)\n",
    "        ax.set_yticklabels([leg1])\n",
    "        ax.set_xlabel(leg_x)\n",
    "        ax.set_title(\"Results by time (s)\")\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(\"rain_cloud_time_sdg.jpg\", dpi=300)\n",
    "        plt.show()\n",
    "\n",
    "    \n",
    "# Criar uma instância da classe ExamplePlotter\n",
    "plotter = Plotter()\n",
    "\n",
    "# Nome da variável a ser plotada\n",
    "y = \"SDG\"\n",
    "x = \"Values (seconds)\"\n",
    "\n",
    "# Chamar a função para plotar o gráfico\n",
    "plotter.plot_by_variable(y, x, list_time_seconds)\n",
    "\n",
    "#time_list = [random.uniform(0.5, 3.5) for _ in range(100)]\n",
    "#plotter.plot_by_variable(y, x, time_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31 horas, 2 minutos e 45.866 segundos\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "\n",
    "def converter_segundos(tempo_em_segundos):\n",
    "    horas = int(tempo_em_segundos // 3600)\n",
    "    minutos = int((tempo_em_segundos % 3600) // 60)\n",
    "    segundos = tempo_em_segundos % 60\n",
    "    return horas, minutos, segundos\n",
    "\n",
    "tempo_em_segundos = max(list_time_seconds)\n",
    "horas, minutos, segundos = converter_segundos(tempo_em_segundos)\n",
    "\n",
    "print(f\"{horas} horas, {minutos} minutos e {segundos:.3f} segundos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Exemplo de classe que utiliza a função plot_by_variable\n",
    "class Plotter:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def plot_by_variable(self, leg1, leg2, leg_x, time_list1, time_list2):\n",
    "        # Define o tamanho da figura\n",
    "        fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "        # Dados\n",
    "        data_x = [time_list1, time_list2]\n",
    "\n",
    "        # Cores para os gráficos\n",
    "        boxplots_colors = ['yellowgreen', 'lightblue']\n",
    "        violin_colors = ['thistle', 'lightcyan']\n",
    "        scatter_colors = ['tomato', 'darksalmon']\n",
    "\n",
    "        # Boxplot\n",
    "        bp = ax.boxplot(data_x, patch_artist=True, vert=False, positions=[1, 2], widths=0.6)\n",
    "        for patch, color in zip(bp['boxes'], boxplots_colors):\n",
    "            patch.set_facecolor(color)\n",
    "            patch.set_alpha(0.4)\n",
    "\n",
    "        # Violinplot\n",
    "        vp = ax.violinplot(data_x, points=500, showmeans=True, showextrema=True, showmedians=False, vert=False)\n",
    "        for idx, b in enumerate(vp['bodies']):\n",
    "            b.set_color(violin_colors[idx])\n",
    "            b.set_alpha(0.6)\n",
    "\n",
    "        # Scatterplot\n",
    "        for idx, features in enumerate(data_x):\n",
    "            y = np.full(len(features), idx + 1)\n",
    "            jitter = np.random.uniform(low=-0.1, high=0.1, size=len(features))\n",
    "            ax.scatter(features + jitter, y, s=15, c=scatter_colors[idx], alpha=0.7, edgecolor='k')\n",
    "\n",
    "        # Configurações do gráfico\n",
    "        ax.set_yticks([1, 2])\n",
    "        ax.grid(False)\n",
    "        ax.set_yticklabels([leg1, leg2])\n",
    "        ax.set_xlabel(leg_x)\n",
    "        ax.set_title(\"Results by time (s)\")\n",
    "        ax.legend(loc='upper right', bbox_to_anchor=(1.1, 1))\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(\"rain_cloud_time_sdg_sam.jpg\", dpi=300)\n",
    "        plt.show()\n",
    "\n",
    "       \n",
    "# Criar uma instância da classe Plotter\n",
    "plotter = Plotter()\n",
    "\n",
    "# Gerar duas listas de tempos de exemplo (em segundos)\n",
    "random.seed(42)  # Para reprodutibilidade\n",
    "time_list1 = [random.uniform(0.5, 3.5) for _ in range(100)]\n",
    "time_list2 = [random.uniform(1.0, 4.0) for _ in range(100)]\n",
    "\n",
    "# Nome da variável a ser plotada\n",
    "variable = \"Execution Time\"\n",
    "\n",
    "# Chamar a função para plotar o gráfico\n",
    "plotter.plot_by_variable(\"Static Analyses\", \"SDG\", \"Values (seconds)\", time_list1, time_list2)\n"
   ]
  }
 ],
 "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.9.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}