app_case_setup.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "# os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
    "# os.environ[\"LANGCHAIN_PROJECT\"] = \"tx generator - setup\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "from enum import Enum\n",
    "from pytz import timezone\n",
    "\n",
    "from case_code.code_downloader import CodeDownloader, get_metadata\n",
    "from case_code.code_loader import CodeLoader\n",
    "from case_code.code_converter import convert, get_conversion_stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionType(Enum):\n",
    "    DOWNLOAD = \"download\"\n",
    "    CONVERT = \"conversion\"\n",
    "\n",
    "\n",
    "def get_time_difference_desc(dt_object: datetime) -> str:\n",
    "    now = datetime.now()\n",
    "    time_diff = now - dt_object\n",
    "\n",
    "    seconds = time_diff.total_seconds()\n",
    "    minutes = seconds // 60\n",
    "    hours = minutes // 60\n",
    "    days = time_diff.days\n",
    "\n",
    "    if seconds < 60:\n",
    "        return \"a few seconds ago\"\n",
    "    elif minutes < 60:\n",
    "        return f\"{int(minutes)} minute{'s' if minutes > 1 else ''} ago\"\n",
    "    elif hours < 24:\n",
    "        return f\"{int(hours)} hour{'s' if hours > 1 else ''} ago\"\n",
    "    else:\n",
    "        return f\"{days} day{'s' if days > 1 else ''} ago\"\n",
    "\n",
    "\n",
    "def should_continue_action(action_type: ActionType, metadata_func) -> bool:\n",
    "    process_action = True  # Default to processing the action\n",
    "\n",
    "    try:\n",
    "        metadata = metadata_func()\n",
    "        dt_object = datetime.fromtimestamp(metadata[\"last_updated\"])\n",
    "        readable_date = dt_object.strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    "\n",
    "        # Prepare the prompt message based on the action type\n",
    "        prompt_message = {\n",
    "            ActionType.DOWNLOAD: \"Do you want to download the latest files?\",\n",
    "            ActionType.CONVERT: \"Do you want to process conversion?\",\n",
    "        }.get(action_type, \"Do you want to proceed?\")\n",
    "\n",
    "        print(f\"Last updated: {readable_date} ({get_time_difference_desc(dt_object)})\")\n",
    "        response = input(\n",
    "            f\"Last updated was {readable_date} ({get_time_difference_desc(dt_object)}). {prompt_message} (y/n) \"\n",
    "        )\n",
    "        process_action = response.lower() in {\"y\", \"Yes\"}\n",
    "    except FileNotFoundError as e:\n",
    "        print(\n",
    "            f\"No {action_type.value} metadata found. Proceeding with {action_type.value}.\"\n",
    "        )\n",
    "    except Exception as e:\n",
    "        print(f\"Error occurred: {str(e)}. Proceeding with {action_type.value}.\")\n",
    "\n",
    "    return process_action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Download source code\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last updated: 2024-08-23 13:55:14 (40 minutes ago)\n"
     ]
    }
   ],
   "source": [
    "shall_download = should_continue_action(ActionType.DOWNLOAD, get_metadata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if shall_download:\n",
    "    downloader = CodeDownloader()\n",
    "    downloaded_count = downloader.download()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total files: 125\n",
      "Total cases: 110\n"
     ]
    }
   ],
   "source": [
    "metadata = get_metadata()\n",
    "print(f\"Total files: {metadata['total_files']}\")\n",
    "print(f\"Total cases: {metadata['total_cases']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert source code\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No conversion metadata found. Proceeding with conversion.\n"
     ]
    }
   ],
   "source": [
    "shall_continue = should_continue_action(ActionType.CONVERT, get_conversion_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start converting with gemini-1.5-pro...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Converting:   0%|          | 0/125 [00:00<?, ?file/s]WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "I0000 00:00:1724394922.105258  395519 check_gcp_environment_no_op.cc:29] ALTS: Platforms other than Linux and Windows are not supported\n",
      "Converting: 100%|██████████| 125/125 [08:46<00:00,  4.21s/file]\n"
     ]
    }
   ],
   "source": [
    "if shall_continue:\n",
    "    loader = CodeLoader()\n",
    "    conversion_stats = await convert(loader=loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time used: 8m 46s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Title</th>\n",
       "      <th>Count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Total Cases</td>\n",
       "      <td>110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Failed Cases</td>\n",
       "      <td>52</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Title  Count\n",
       "0   Total Cases    110\n",
       "1  Failed Cases     52"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats = get_conversion_stats()\n",
    "\n",
    "minutes, seconds = divmod(stats[\"total_time_taken\"], 60)\n",
    "# Construct the output message\n",
    "if minutes > 0:\n",
    "    print(f\"Time used: {minutes}m {seconds}s\")\n",
    "else:\n",
    "    print(f\"Time used: {seconds}s\")\n",
    "\n",
    "data = {\n",
    "    \"Title\": [\"Total Cases\", \"Failed Cases\"],\n",
    "    \"Count\": [stats[\"total_cases\"], stats[\"failed_cases\"]],\n",
    "}\n",
    "pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aggregate stats from all models\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>gpt-4o-mini</th>\n",
       "      <th>gpt-4o-2024-08-06</th>\n",
       "      <th>gpt-4o</th>\n",
       "      <th>claude-3-5-sonnet-20240620</th>\n",
       "      <th>gemini-1.5-pro</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Last Updated</th>\n",
       "      <td>2024-08-23 13:57:30</td>\n",
       "      <td>2024-08-23 14:03:49</td>\n",
       "      <td>2024-08-23 14:08:24</td>\n",
       "      <td>2024-08-23 14:15:35</td>\n",
       "      <td>2024-08-23 14:44:08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Duration (sec)</th>\n",
       "      <td>135</td>\n",
       "      <td>257</td>\n",
       "      <td>217</td>\n",
       "      <td>390</td>\n",
       "      <td>526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Successful Cases / Total Cases</th>\n",
       "      <td>110 / 110</td>\n",
       "      <td>110 / 110</td>\n",
       "      <td>110 / 110</td>\n",
       "      <td>73 / 110</td>\n",
       "      <td>58 / 110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Success Rate (%)</th>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>66.363636</td>\n",
       "      <td>52.727273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Converted Cases per Sec</th>\n",
       "      <td>0.814815</td>\n",
       "      <td>0.428016</td>\n",
       "      <td>0.506912</td>\n",
       "      <td>0.187179</td>\n",
       "      <td>0.110266</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                        gpt-4o-mini    gpt-4o-2024-08-06  \\\n",
       "Last Updated                    2024-08-23 13:57:30  2024-08-23 14:03:49   \n",
       "Duration (sec)                                  135                  257   \n",
       "Successful Cases / Total Cases            110 / 110            110 / 110   \n",
       "Success Rate (%)                              100.0                100.0   \n",
       "Converted Cases per Sec                    0.814815             0.428016   \n",
       "\n",
       "                                             gpt-4o  \\\n",
       "Last Updated                    2024-08-23 14:08:24   \n",
       "Duration (sec)                                  217   \n",
       "Successful Cases / Total Cases            110 / 110   \n",
       "Success Rate (%)                              100.0   \n",
       "Converted Cases per Sec                    0.506912   \n",
       "\n",
       "                               claude-3-5-sonnet-20240620       gemini-1.5-pro  \n",
       "Last Updated                          2024-08-23 14:15:35  2024-08-23 14:44:08  \n",
       "Duration (sec)                                        390                  526  \n",
       "Successful Cases / Total Cases                   73 / 110             58 / 110  \n",
       "Success Rate (%)                                66.363636            52.727273  \n",
       "Converted Cases per Sec                          0.187179             0.110266  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from case_code.code_converter import get_all_conversion_stats\n",
    "\n",
    "# Fetch and load stats into a DataFrame\n",
    "stats = get_all_conversion_stats()\n",
    "df = pd.DataFrame(stats)\n",
    "\n",
    "# Convert and format the 'last_updated' timestamps to local time\n",
    "local_tz = timezone(\"Asia/Taipei\")\n",
    "df.loc[\"last_updated\"] = (\n",
    "    pd.to_datetime(df.loc[\"last_updated\"], unit=\"s\")\n",
    "    .dt.tz_localize(\"UTC\")\n",
    "    .dt.tz_convert(local_tz)\n",
    "    .dt.strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    ")\n",
    "\n",
    "successful_cases = df.loc[\"total_cases\"] - df.loc[\"failed_cases\"]\n",
    "\n",
    "df.loc[\"successful_cases_total\"] = (\n",
    "    successful_cases.astype(str) + \" / \" + df.loc[\"total_cases\"].astype(str)\n",
    ")\n",
    "\n",
    "# Calculate the success rate\n",
    "df.loc[\"success_rate\"] = successful_cases / df.loc[\"total_cases\"] * 100\n",
    "\n",
    "# Calculate the success case per second\n",
    "df.loc[\"success_case_per_sec\"] = successful_cases / df.loc[\"total_time_taken\"]\n",
    "\n",
    "\n",
    "# Drop the rows\n",
    "df.drop(index=[\"cases\", \"total_cases\", \"failed_cases\"], inplace=True)\n",
    "\n",
    "# Rename the index labels for better readability\n",
    "df.rename(\n",
    "    index={\n",
    "        \"last_updated\": \"Last Updated\",\n",
    "        \"total_time_taken\": \"Duration (sec)\",\n",
    "        \"successful_cases_total\": \"Successful Cases / Total Cases\",\n",
    "        \"success_rate\": \"Success Rate (%)\",\n",
    "        \"success_case_per_sec\": \"Converted Cases per Sec\",\n",
    "    },\n",
    "    inplace=True,\n",
    ")\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from case_code.code_converter import sort_converted_cases\n",
    "\n",
    "# Post-conversion sorting for better readability\n",
    "sort_converted_cases()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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
}