{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5442bddd",
   "metadata": {},
   "source": [
    "## 1. Install packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c2006292",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  WARNING: The script tqdm.exe is installed in 'C:\\Users\\User\\AppData\\Roaming\\Python\\Python312\\Scripts' which is not on PATH.\n",
      "  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.\n",
      "  WARNING: The scripts f2py.exe and numpy-config.exe are installed in 'C:\\Users\\User\\AppData\\Roaming\\Python\\Python312\\Scripts' which is not on PATH.\n",
      "  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.\n",
      "  WARNING: Failed to remove contents in a temporary directory 'C:\\Users\\User\\AppData\\Roaming\\Python\\Python312\\site-packages\\~andas.libs'.\n",
      "  You can safely remove it manually.\n",
      "  WARNING: Failed to remove contents in a temporary directory 'C:\\Users\\User\\AppData\\Roaming\\Python\\Python312\\site-packages\\~andas'.\n",
      "  You can safely remove it manually.\n",
      "  WARNING: The scripts hf.exe, huggingface-cli.exe and tiny-agents.exe are installed in 'C:\\Users\\User\\AppData\\Roaming\\Python\\Python312\\Scripts' which is not on PATH.\n",
      "  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.\n",
      "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
      "shap 0.41.0 requires slicer==0.0.7, which is not installed.\n",
      "albucore 0.0.20 requires simsimd>=5.9.2, which is not installed.\n",
      "albucore 0.0.20 requires stringzilla>=3.10.4, which is not installed.\n",
      "httpcore2 2.12.0 requires h11>=0.16, but you have h11 0.14.0 which is incompatible.\n",
      "sklearn-compat 0.1.5 requires scikit-learn<1.9,>=1.2, but you have scikit-learn 1.9.1 which is incompatible.\n",
      "transformers 4.57.3 requires huggingface-hub<1.0,>=0.34.0, but you have huggingface-hub 1.31.0 which is incompatible.\n",
      "gensim 4.3.3 requires numpy<2.0,>=1.18.5, but you have numpy 2.5.3 which is incompatible.\n",
      "gensim 4.3.3 requires scipy<1.14.0,>=1.7.0, but you have scipy 1.17.1 which is incompatible.\n",
      "numba 0.60.0 requires numpy<2.1,>=1.22, but you have numpy 2.5.3 which is incompatible.\n",
      "streamlit 1.37.1 requires pandas<3,>=1.3.0, but you have pandas 3.0.5 which is incompatible.\n",
      "streamlit 1.37.1 requires protobuf<6,>=3.20, but you have protobuf 6.33.1 which is incompatible.\n",
      "streamlit 1.37.1 requires rich<14,>=10.14.0, but you have rich 15.0.0 which is incompatible.\n"
     ]
    }
   ],
   "source": [
    "%pip install -q -U huggingface_hub pandas numpy scikit-learn matplotlib seaborn tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae65700f",
   "metadata": {},
   "source": [
    "## 2. Imports and configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9ed1abf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset: D:\\PHEME_PLUS\\all-rnr-annotated-threads\n",
      "Model: openai/gpt-oss-120b\n",
      "Provider: auto\n",
      "Repeats: 3\n",
      "Target per class: 100\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import re\n",
    "import json\n",
    "import time\n",
    "import random\n",
    "from pathlib import Path\n",
    "from datetime import datetime\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "from sklearn.metrics import (\n",
    "    accuracy_score,\n",
    "    precision_recall_fscore_support,\n",
    "    confusion_matrix,\n",
    "    cohen_kappa_score\n",
    ")\n",
    "\n",
    "RANDOM_STATE = 42\n",
    "random.seed(RANDOM_STATE)\n",
    "np.random.seed(RANDOM_STATE)\n",
    "\n",
    "DATASET_ROOT = Path(r\"D:\\PHEME_PLUS\\all-rnr-annotated-threads\")\n",
    "OUTPUT_DIR = DATASET_ROOT.parent / \"chapter4_outputs\"\n",
    "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "MODEL_NAME = \"openai/gpt-oss-120b\"\n",
    "HF_PROVIDER = \"auto\"\n",
    "\n",
    "PROMPT_TYPES = [\"Zero-Shot\", \"Definition-Based\", \"Few-Shot\"]\n",
    "LABELS = [\"Reliable/Supported\", \"Misleading/False\", \"Unverified\"]\n",
    "\n",
    "REPEATS = 3\n",
    "TARGET_PER_CLASS = 100\n",
    "\n",
    "RUN_LLM_EXPERIMENT = True\n",
    "RUN_FULL_EXPERIMENT = False\n",
    "\n",
    "TEMPERATURE = 0.2\n",
    "MAX_TOKENS = 500\n",
    "\n",
    "print(\"Dataset:\", DATASET_ROOT)\n",
    "print(\"Model:\", MODEL_NAME)\n",
    "print(\"Provider:\", HF_PROVIDER)\n",
    "print(\"Repeats:\", REPEATS)\n",
    "print(\"Target per class:\", TARGET_PER_CLASS)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44df6804",
   "metadata": {},
   "source": [
    "## 3. Verify HF token"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2ef2470f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HF token loaded: True\n",
      "Token prefix: hf_jIFK...\n"
     ]
    }
   ],
   "source": [
    "HF_TOKEN = os.getenv(\"HF_TOKEN\")\n",
    "\n",
    "print(\"HF token loaded:\", HF_TOKEN is not None)\n",
    "\n",
    "if not HF_TOKEN:\n",
    "    raise RuntimeError(\n",
    "        \"HF_TOKEN was not found. Set HF_TOKEN as an environment variable \"\n",
    "        \"and restart the Jupyter kernel.\"\n",
    "    )\n",
    "\n",
    "print(\"Token prefix:\", HF_TOKEN[:7] + \"...\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d0630c2",
   "metadata": {},
   "source": [
    "## 4. Configure Hugging Face InferenceClient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "885dc0af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hugging Face InferenceClient configured successfully.\n"
     ]
    }
   ],
   "source": [
    "from huggingface_hub import InferenceClient\n",
    "\n",
    "client = InferenceClient(\n",
    "    api_key=HF_TOKEN,\n",
    "    provider=HF_PROVIDER\n",
    ")\n",
    "\n",
    "print(\"Hugging Face InferenceClient configured successfully.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45f53165",
   "metadata": {},
   "source": [
    "## 5. API smoke test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "862d3997",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "API TEST: SUCCESS\n",
      "Model: openai/gpt-oss-120b\n",
      "Response: 'API_TEST_SUCCESS'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    response = client.chat.completions.create(\n",
    "        model=MODEL_NAME,\n",
    "        messages=[\n",
    "            {\"role\": \"system\", \"content\": \"You are a concise test assistant.\"},\n",
    "            {\"role\": \"user\", \"content\": \"Reply with exactly API_TEST_SUCCESS\"}\n",
    "        ],\n",
    "        temperature=0.0,\n",
    "        max_tokens=50\n",
    "    )\n",
    "\n",
    "    text = response.choices[0].message.content or \"\"\n",
    "\n",
    "    print(\"API TEST: SUCCESS\")\n",
    "    print(\"Model:\", MODEL_NAME)\n",
    "    print(\"Response:\", repr(text))\n",
    "\n",
    "except Exception as e:\n",
    "    print(\"API TEST: FAILED\")\n",
    "    print(\"Error type:\", type(e).__name__)\n",
    "    print(\"Error:\", str(e))\n",
    "    raise\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e6fc16",
   "metadata": {},
   "source": [
    "## 6. Verify dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e523e8a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Events found:\n",
      " - charliehebdo-all-rnr-threads\n",
      " - ferguson-all-rnr-threads\n",
      " - germanwings-crash-all-rnr-threads\n",
      " - ottawashooting-all-rnr-threads\n",
      " - sydneysiege-all-rnr-threads\n"
     ]
    }
   ],
   "source": [
    "if not DATASET_ROOT.exists():\n",
    "    raise FileNotFoundError(f\"Dataset root not found: {DATASET_ROOT}\")\n",
    "\n",
    "event_dirs = sorted(p for p in DATASET_ROOT.iterdir() if p.is_dir())\n",
    "\n",
    "print(\"Events found:\")\n",
    "for p in event_dirs:\n",
    "    print(\" -\", p.name)\n",
    "\n",
    "if not event_dirs:\n",
    "    raise RuntimeError(\"No event directories found.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52b9c52b",
   "metadata": {},
   "source": [
    "## 7. PHEMEPlus helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "77068115",
   "metadata": {},
   "outputs": [],
   "source": [
    "def safe_load_json(path):\n",
    "    try:\n",
    "        with open(path, \"r\", encoding=\"utf-8\") as f:\n",
    "            return json.load(f)\n",
    "    except Exception:\n",
    "        return None\n",
    "\n",
    "\n",
    "def extract_source_tweet(thread_dir):\n",
    "    folder = thread_dir / \"source-tweets\"\n",
    "    files = sorted(folder.glob(\"*.json\")) if folder.exists() else []\n",
    "\n",
    "    if not files:\n",
    "        return None\n",
    "\n",
    "    data = safe_load_json(files[0])\n",
    "    if not data:\n",
    "        return None\n",
    "\n",
    "    return {\n",
    "        \"tweet_id\": str(data.get(\"id\", files[0].stem)),\n",
    "        \"source_text\": str(data.get(\"text\", \"\")).strip()\n",
    "    }\n",
    "\n",
    "\n",
    "def extract_annotation(thread_dir):\n",
    "    path = thread_dir / \"annotation.json\"\n",
    "    return safe_load_json(path) if path.exists() else None\n",
    "\n",
    "\n",
    "def extract_google_urls(thread_dir):\n",
    "    folder = thread_dir / \"google\"\n",
    "    if not folder.exists():\n",
    "        return []\n",
    "\n",
    "    urls = []\n",
    "\n",
    "    for path in sorted(folder.rglob(\"*\")):\n",
    "        if path.is_file():\n",
    "            text = path.read_text(\n",
    "                encoding=\"utf-8\",\n",
    "                errors=\"ignore\"\n",
    "            ).strip()\n",
    "\n",
    "            if text.startswith((\"http://\", \"https://\")):\n",
    "                urls.append(text.splitlines()[0].strip())\n",
    "\n",
    "    return list(dict.fromkeys(urls))\n",
    "\n",
    "\n",
    "def map_pheme_veracity(annotation):\n",
    "    \"\"\"\n",
    "    Convert PHEME annotation fields into:\n",
    "    True, False, Unverified, or UNMAPPED.\n",
    "    Handles both integer and string values.\n",
    "    \"\"\"\n",
    "\n",
    "    if not annotation:\n",
    "        return \"UNMAPPED\"\n",
    "\n",
    "    misinformation = annotation.get(\"misinformation\")\n",
    "    true_value = annotation.get(\"true\")\n",
    "\n",
    "    # Convert string values such as \"0\" / \"1\" to integers\n",
    "    try:\n",
    "        misinformation = int(misinformation)\n",
    "    except (TypeError, ValueError):\n",
    "        return \"UNMAPPED\"\n",
    "\n",
    "    try:\n",
    "        true_value = int(true_value)\n",
    "    except (TypeError, ValueError):\n",
    "        return \"UNMAPPED\"\n",
    "\n",
    "    # PHEME veracity mapping\n",
    "    if misinformation == 0 and true_value == 1:\n",
    "        return \"True\"\n",
    "\n",
    "    elif misinformation == 1 and true_value == 0:\n",
    "        return \"False\"\n",
    "\n",
    "    elif misinformation == 0 and true_value == 0:\n",
    "        return \"Unverified\"\n",
    "\n",
    "    else:\n",
    "        return \"UNMAPPED\"\n",
    "\n",
    "\n",
    "def map_research_label(label):\n",
    "    return {\n",
    "        \"True\": \"Reliable/Supported\",\n",
    "        \"False\": \"Misleading/False\",\n",
    "        \"Unverified\": \"Unverified\"\n",
    "    }.get(label, \"UNMAPPED\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac72bcbb",
   "metadata": {},
   "source": [
    "## 8. Extract rumour threads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "18a87368",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rows extracted: 1972\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>event</th>\n",
       "      <th>thread_id</th>\n",
       "      <th>tweet_id</th>\n",
       "      <th>source_text</th>\n",
       "      <th>claim</th>\n",
       "      <th>pheme_label</th>\n",
       "      <th>research_label</th>\n",
       "      <th>annotation_urls</th>\n",
       "      <th>google_evidence_urls</th>\n",
       "      <th>google_evidence_count</th>\n",
       "      <th>has_google_evidence</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>charliehebdo-all-rnr-threads</td>\n",
       "      <td>552783238415265792</td>\n",
       "      <td>552783238415265792</td>\n",
       "      <td>Breaking: At least 10 dead, 5 injured after tO...</td>\n",
       "      <td>Breaking: At least 10 dead, 5 injured after tO...</td>\n",
       "      <td>True</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>http://www.bbc.co.uk/news/live/world-europe-30...</td>\n",
       "      <td>https://www.washingtonpost.com/world/europe/gu...</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>charliehebdo-all-rnr-threads</td>\n",
       "      <td>552783667052167168</td>\n",
       "      <td>552783667052167168</td>\n",
       "      <td>France: 10 people dead after shooting at HQ of...</td>\n",
       "      <td>France: 10 people dead after shooting at HQ of...</td>\n",
       "      <td>True</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>http://www.bbc.co.uk/news/live/world-europe-30...</td>\n",
       "      <td>https://www.washingtonpost.com/world/europe/gu...</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>charliehebdo-all-rnr-threads</td>\n",
       "      <td>552783745565347840</td>\n",
       "      <td>552783745565347840</td>\n",
       "      <td>Ten killed in shooting at headquarters of Fren...</td>\n",
       "      <td>Ten killed in shooting at headquarters of Fren...</td>\n",
       "      <td>True</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>http://www.bbc.co.uk/news/live/world-europe-30...</td>\n",
       "      <td>https://issuu.com/cencos/docs/attacks_on_the_p...</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>charliehebdo-all-rnr-threads</td>\n",
       "      <td>552784168849907712</td>\n",
       "      <td>552784168849907712</td>\n",
       "      <td>BREAKING: 10 dead in shooting at headquarters ...</td>\n",
       "      <td>BREAKING: 10 dead in shooting at headquarters ...</td>\n",
       "      <td>True</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>http://www.bbc.co.uk/news/live/world-europe-30...</td>\n",
       "      <td>https://www.dailymail.co.uk/news/article-29002...</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>charliehebdo-all-rnr-threads</td>\n",
       "      <td>552784526955806720</td>\n",
       "      <td>552784526955806720</td>\n",
       "      <td>Reuters: 10 people shot dead at headquarters o...</td>\n",
       "      <td>Reuters: 10 people shot dead at headquarters o...</td>\n",
       "      <td>True</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>http://www.bbc.co.uk/news/live/world-europe-30...</td>\n",
       "      <td>https://www.wsj.com/articles/shooting-at-paris...</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          event           thread_id            tweet_id  \\\n",
       "0  charliehebdo-all-rnr-threads  552783238415265792  552783238415265792   \n",
       "1  charliehebdo-all-rnr-threads  552783667052167168  552783667052167168   \n",
       "2  charliehebdo-all-rnr-threads  552783745565347840  552783745565347840   \n",
       "3  charliehebdo-all-rnr-threads  552784168849907712  552784168849907712   \n",
       "4  charliehebdo-all-rnr-threads  552784526955806720  552784526955806720   \n",
       "\n",
       "                                         source_text  \\\n",
       "0  Breaking: At least 10 dead, 5 injured after tO...   \n",
       "1  France: 10 people dead after shooting at HQ of...   \n",
       "2  Ten killed in shooting at headquarters of Fren...   \n",
       "3  BREAKING: 10 dead in shooting at headquarters ...   \n",
       "4  Reuters: 10 people shot dead at headquarters o...   \n",
       "\n",
       "                                               claim pheme_label  \\\n",
       "0  Breaking: At least 10 dead, 5 injured after tO...        True   \n",
       "1  France: 10 people dead after shooting at HQ of...        True   \n",
       "2  Ten killed in shooting at headquarters of Fren...        True   \n",
       "3  BREAKING: 10 dead in shooting at headquarters ...        True   \n",
       "4  Reuters: 10 people shot dead at headquarters o...        True   \n",
       "\n",
       "       research_label                                    annotation_urls  \\\n",
       "0  Reliable/Supported  http://www.bbc.co.uk/news/live/world-europe-30...   \n",
       "1  Reliable/Supported  http://www.bbc.co.uk/news/live/world-europe-30...   \n",
       "2  Reliable/Supported  http://www.bbc.co.uk/news/live/world-europe-30...   \n",
       "3  Reliable/Supported  http://www.bbc.co.uk/news/live/world-europe-30...   \n",
       "4  Reliable/Supported  http://www.bbc.co.uk/news/live/world-europe-30...   \n",
       "\n",
       "                                google_evidence_urls  google_evidence_count  \\\n",
       "0  https://www.washingtonpost.com/world/europe/gu...                     10   \n",
       "1  https://www.washingtonpost.com/world/europe/gu...                     10   \n",
       "2  https://issuu.com/cencos/docs/attacks_on_the_p...                     10   \n",
       "3  https://www.dailymail.co.uk/news/article-29002...                     10   \n",
       "4  https://www.wsj.com/articles/shooting-at-paris...                     10   \n",
       "\n",
       "   has_google_evidence  \n",
       "0                    1  \n",
       "1                    1  \n",
       "2                    1  \n",
       "3                    1  \n",
       "4                    1  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "records = []\n",
    "\n",
    "for event_dir in event_dirs:\n",
    "    rumours_dir = event_dir / \"rumours\"\n",
    "\n",
    "    if not rumours_dir.exists():\n",
    "        continue\n",
    "\n",
    "    for thread_dir in sorted(p for p in rumours_dir.iterdir() if p.is_dir()):\n",
    "        annotation = extract_annotation(thread_dir)\n",
    "        tweet = extract_source_tweet(thread_dir)\n",
    "\n",
    "        if not tweet:\n",
    "            continue\n",
    "\n",
    "        pheme_label = map_pheme_veracity(annotation)\n",
    "        research_label = map_research_label(pheme_label)\n",
    "\n",
    "        annotation_urls = []\n",
    "        if annotation:\n",
    "            annotation_urls = [\n",
    "                item.get(\"link\")\n",
    "                for item in annotation.get(\"links\", [])\n",
    "                if isinstance(item, dict) and item.get(\"link\")\n",
    "            ]\n",
    "\n",
    "        google_urls = extract_google_urls(thread_dir)\n",
    "\n",
    "        records.append({\n",
    "            \"event\": event_dir.name,\n",
    "            \"thread_id\": thread_dir.name,\n",
    "            \"tweet_id\": tweet[\"tweet_id\"],\n",
    "            \"source_text\": tweet[\"source_text\"],\n",
    "            \"claim\": tweet[\"source_text\"],\n",
    "            \"pheme_label\": pheme_label,\n",
    "            \"research_label\": research_label,\n",
    "            \"annotation_urls\": \" | \".join(annotation_urls),\n",
    "            \"google_evidence_urls\": \" | \".join(google_urls),\n",
    "            \"google_evidence_count\": len(google_urls),\n",
    "            \"has_google_evidence\": int(bool(google_urls))\n",
    "        })\n",
    "\n",
    "master_df = pd.DataFrame(records)\n",
    "\n",
    "print(\"Rows extracted:\", len(master_df))\n",
    "display(master_df.head())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d21750e1",
   "metadata": {},
   "source": [
    "## 9. Validate ground truth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "974824f0",
   "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>count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pheme_label</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>True</th>\n",
       "      <td>1008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Unverified</th>\n",
       "      <td>571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>False</th>\n",
       "      <td>393</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count\n",
       "pheme_label       \n",
       "True          1008\n",
       "Unverified     571\n",
       "False          393"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>research_label</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Reliable/Supported</th>\n",
       "      <td>1008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Unverified</th>\n",
       "      <td>571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Misleading/False</th>\n",
       "      <td>393</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    count\n",
       "research_label           \n",
       "Reliable/Supported   1008\n",
       "Unverified            571\n",
       "Misleading/False      393"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unmapped: 0\n"
     ]
    }
   ],
   "source": [
    "display(master_df[\"pheme_label\"].value_counts(dropna=False).to_frame(\"count\"))\n",
    "display(master_df[\"research_label\"].value_counts(dropna=False).to_frame(\"count\"))\n",
    "\n",
    "unmapped = master_df[master_df[\"research_label\"] == \"UNMAPPED\"]\n",
    "\n",
    "print(\"Unmapped:\", len(unmapped))\n",
    "\n",
    "if len(unmapped):\n",
    "    display(unmapped.head(20))\n",
    "\n",
    "assert len(master_df) > 0\n",
    "assert len(unmapped) == 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "569b2a01",
   "metadata": {},
   "source": [
    "## 10. Dataset quality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f69f0781",
   "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>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Total rumour threads</th>\n",
       "      <td>1972</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Unique thread IDs</th>\n",
       "      <td>1972</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Unique tweet IDs</th>\n",
       "      <td>1972</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Blank source text</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Evidence URL available</th>\n",
       "      <td>1848</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>No evidence URL</th>\n",
       "      <td>124</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Value\n",
       "Total rumour threads     1972\n",
       "Unique thread IDs        1972\n",
       "Unique tweet IDs         1972\n",
       "Blank source text           0\n",
       "Evidence URL available   1848\n",
       "No evidence URL           124"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "quality = pd.Series({\n",
    "    \"Total rumour threads\": len(master_df),\n",
    "    \"Unique thread IDs\": master_df[\"thread_id\"].nunique(),\n",
    "    \"Unique tweet IDs\": master_df[\"tweet_id\"].nunique(),\n",
    "    \"Blank source text\": master_df[\"source_text\"].fillna(\"\").str.strip().eq(\"\").sum(),\n",
    "    \"Evidence URL available\": master_df[\"has_google_evidence\"].sum(),\n",
    "    \"No evidence URL\": (master_df[\"has_google_evidence\"] == 0).sum()\n",
    "})\n",
    "\n",
    "display(quality.to_frame(\"Value\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc10e604",
   "metadata": {},
   "source": [
    "## 11. Figure 4.1 — Event distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "4ce98e19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "master_df[\"event\"].value_counts().sort_index().plot(\n",
    "    kind=\"bar\", figsize=(10,5)\n",
    ")\n",
    "plt.title(\"Figure 4.1: PHEMEPlus Rumour Threads by Event\")\n",
    "plt.xlabel(\"Event\")\n",
    "plt.ylabel(\"Number of rumour threads\")\n",
    "plt.xticks(rotation=35, ha=\"right\")\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69d5a488",
   "metadata": {},
   "source": [
    "## 12. Figure 4.2 — Veracity distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "58b224e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "master_df[\"research_label\"].value_counts().reindex(LABELS).plot(\n",
    "    kind=\"bar\", figsize=(8,5)\n",
    ")\n",
    "plt.title(\"Figure 4.2: Ground-Truth Veracity Distribution\")\n",
    "plt.xlabel(\"Research label\")\n",
    "plt.ylabel(\"Number of rumour threads\")\n",
    "plt.xticks(rotation=20)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d95f820a",
   "metadata": {},
   "source": [
    "## 13. Figure 4.3 — Veracity by event"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "203114d4",
   "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>research_label</th>\n",
       "      <th>Reliable/Supported</th>\n",
       "      <th>Misleading/False</th>\n",
       "      <th>Unverified</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>event</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>charliehebdo-all-rnr-threads</th>\n",
       "      <td>193</td>\n",
       "      <td>116</td>\n",
       "      <td>149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ferguson-all-rnr-threads</th>\n",
       "      <td>10</td>\n",
       "      <td>8</td>\n",
       "      <td>266</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>germanwings-crash-all-rnr-threads</th>\n",
       "      <td>94</td>\n",
       "      <td>111</td>\n",
       "      <td>33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ottawashooting-all-rnr-threads</th>\n",
       "      <td>329</td>\n",
       "      <td>72</td>\n",
       "      <td>69</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sydneysiege-all-rnr-threads</th>\n",
       "      <td>382</td>\n",
       "      <td>86</td>\n",
       "      <td>54</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "research_label                     Reliable/Supported  Misleading/False  \\\n",
       "event                                                                     \n",
       "charliehebdo-all-rnr-threads                      193               116   \n",
       "ferguson-all-rnr-threads                           10                 8   \n",
       "germanwings-crash-all-rnr-threads                  94               111   \n",
       "ottawashooting-all-rnr-threads                    329                72   \n",
       "sydneysiege-all-rnr-threads                       382                86   \n",
       "\n",
       "research_label                     Unverified  \n",
       "event                                          \n",
       "charliehebdo-all-rnr-threads              149  \n",
       "ferguson-all-rnr-threads                  266  \n",
       "germanwings-crash-all-rnr-threads          33  \n",
       "ottawashooting-all-rnr-threads             69  \n",
       "sydneysiege-all-rnr-threads                54  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "event_veracity = pd.crosstab(\n",
    "    master_df[\"event\"],\n",
    "    master_df[\"research_label\"]\n",
    ").reindex(columns=LABELS, fill_value=0)\n",
    "\n",
    "display(event_veracity)\n",
    "\n",
    "event_veracity.plot(kind=\"bar\", figsize=(11,6))\n",
    "plt.title(\"Figure 4.3: Ground-Truth Veracity by Event\")\n",
    "plt.xlabel(\"Event\")\n",
    "plt.ylabel(\"Number of rumour threads\")\n",
    "plt.xticks(rotation=35, ha=\"right\")\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60bbba5f",
   "metadata": {},
   "source": [
    "## 14. Figure 4.4 — Evidence availability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "0a5cf021",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "master_df[\"has_google_evidence\"].map({\n",
    "    1: \"Evidence URL available\",\n",
    "    0: \"No evidence URL\"\n",
    "}).value_counts().plot(kind=\"bar\", figsize=(8,5))\n",
    "\n",
    "plt.title(\"Figure 4.4: PHEMEPlus Evidence URL Availability\")\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"Number of rumour threads\")\n",
    "plt.xticks(rotation=0)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10ac1961",
   "metadata": {},
   "source": [
    "## 15. Create stratified evaluation sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "99abe44c",
   "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>available</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>research_label</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Reliable/Supported</th>\n",
       "      <td>1008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Misleading/False</th>\n",
       "      <td>393</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Unverified</th>\n",
       "      <td>571</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    available\n",
       "research_label               \n",
       "Reliable/Supported       1008\n",
       "Misleading/False          393\n",
       "Unverified                571"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Experiment sample: (300, 11)\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>sample_count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>research_label</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Reliable/Supported</th>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Misleading/False</th>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Unverified</th>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    sample_count\n",
       "research_label                  \n",
       "Reliable/Supported           100\n",
       "Misleading/False             100\n",
       "Unverified                   100"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "available = master_df[\"research_label\"].value_counts().reindex(LABELS)\n",
    "display(available.to_frame(\"available\"))\n",
    "\n",
    "parts = []\n",
    "\n",
    "for label in LABELS:\n",
    "    subset = master_df[master_df[\"research_label\"] == label]\n",
    "    n = min(TARGET_PER_CLASS, len(subset))\n",
    "\n",
    "    if n == 0:\n",
    "        raise ValueError(f\"No records available for {label}\")\n",
    "\n",
    "    parts.append(\n",
    "        subset.sample(n=n, random_state=RANDOM_STATE)\n",
    "    )\n",
    "\n",
    "experiment_df = (\n",
    "    pd.concat(parts, ignore_index=True)\n",
    "    .sample(frac=1, random_state=RANDOM_STATE)\n",
    "    .reset_index(drop=True)\n",
    ")\n",
    "\n",
    "print(\"Experiment sample:\", experiment_df.shape)\n",
    "display(\n",
    "    experiment_df[\"research_label\"]\n",
    "    .value_counts()\n",
    "    .reindex(LABELS)\n",
    "    .to_frame(\"sample_count\")\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e39cecd",
   "metadata": {},
   "source": [
    "## 16. Create disjoint few-shot demonstrations\n",
    "\n",
    "The few-shot examples are selected **outside the evaluation sample**, preventing an evaluation claim from also being used as a demonstration.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "1bfabb0e",
   "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>thread_id</th>\n",
       "      <th>research_label</th>\n",
       "      <th>source_text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>544512691948498944</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>Gunfire at Sydney cafe where hostages held; re...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>500287224957898752</td>\n",
       "      <td>Misleading/False</td>\n",
       "      <td>Being shot 10 times in the street for stealing...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>553468492700454912</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>BREAKING NEWS - Exchange of fire reported in #...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            thread_id      research_label  \\\n",
       "0  544512691948498944  Reliable/Supported   \n",
       "1  500287224957898752    Misleading/False   \n",
       "2  553468492700454912          Unverified   \n",
       "\n",
       "                                         source_text  \n",
       "0  Gunfire at Sydney cafe where hostages held; re...  \n",
       "1  Being shot 10 times in the street for stealing...  \n",
       "2  BREAKING NEWS - Exchange of fire reported in #...  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "remaining_df = master_df[\n",
    "    ~master_df[\"thread_id\"].isin(set(experiment_df[\"thread_id\"]))\n",
    "].copy()\n",
    "\n",
    "demo_parts = []\n",
    "\n",
    "for label in LABELS:\n",
    "    subset = remaining_df[\n",
    "        remaining_df[\"research_label\"] == label\n",
    "    ]\n",
    "\n",
    "    if len(subset) == 0:\n",
    "        raise ValueError(f\"No demonstration available for {label}\")\n",
    "\n",
    "    demo_parts.append(\n",
    "        subset.sample(n=1, random_state=RANDOM_STATE)\n",
    "    )\n",
    "\n",
    "demo_df = pd.concat(demo_parts, ignore_index=True)\n",
    "\n",
    "display(\n",
    "    demo_df[\n",
    "        [\"thread_id\", \"research_label\", \"source_text\"]\n",
    "    ]\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9e79956",
   "metadata": {},
   "source": [
    "## 17. Prompt definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "dffa0ac0",
   "metadata": {},
   "outputs": [],
   "source": [
    "SYSTEM_INSTRUCTION = \"\"\"\n",
    "You are a research assistant performing three-class rumour veracity classification.\n",
    "\n",
    "Classify ONLY the claim supplied by the user.\n",
    "\n",
    "Use exactly one classification:\n",
    "1. Reliable/Supported\n",
    "2. Misleading/False\n",
    "3. Unverified\n",
    "\n",
    "Definitions:\n",
    "- Reliable/Supported: the claim is supported as true by the information available.\n",
    "- Misleading/False: the claim is contradicted by reliable information or is false.\n",
    "- Unverified: there is insufficient information to establish whether the claim is true or false.\n",
    "\n",
    "Rules:\n",
    "- Do not treat the fact that a post is a rumour as evidence that it is false.\n",
    "- Do not infer truth from writing style, confidence, virality, or plausibility.\n",
    "- If the claim cannot be established as true or false from the available information, choose Unverified.\n",
    "\n",
    "Return ONLY valid JSON:\n",
    "{\"classification\":\"Reliable/Supported\",\"explanation\":\"brief explanation\"}\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def build_zero_shot(claim):\n",
    "    return f\"\"\"Classify the following claim using the three labels in the system instruction.\n",
    "\n",
    "CLAIM:\n",
    "{claim}\n",
    "\n",
    "Return only the required JSON object.\"\"\"\n",
    "\n",
    "\n",
    "def build_definition_based(claim):\n",
    "    return f\"\"\"Classify the following claim using the definitions in the system instruction.\n",
    "\n",
    "Distinguish carefully between a false claim and a claim that is simply unverified.\n",
    "\n",
    "CLAIM:\n",
    "{claim}\n",
    "\n",
    "Return only the required JSON object.\"\"\"\n",
    "\n",
    "\n",
    "def build_few_shot(claim):\n",
    "    examples = []\n",
    "\n",
    "    for _, row in demo_df.iterrows():\n",
    "        examples.append(\n",
    "            \"Example claim:\\n\"\n",
    "            + row[\"source_text\"]\n",
    "            + \"\\nExample classification:\\n\"\n",
    "            + row[\"research_label\"]\n",
    "        )\n",
    "\n",
    "    demonstrations = \"\\n\\n\".join(examples)\n",
    "\n",
    "    return f\"\"\"Use the following labelled examples as demonstrations.\n",
    "\n",
    "{demonstrations}\n",
    "\n",
    "Now classify this new claim:\n",
    "\n",
    "NEW CLAIM:\n",
    "{claim}\n",
    "\n",
    "Return only the required JSON object.\"\"\"\n",
    "\n",
    "\n",
    "PROMPT_BUILDERS = {\n",
    "    \"Zero-Shot\": build_zero_shot,\n",
    "    \"Definition-Based\": build_definition_based,\n",
    "    \"Few-Shot\": build_few_shot\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebcee257",
   "metadata": {},
   "source": [
    "## 18. Robust JSON parser and model-call function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "5a22a625",
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_prediction(value):\n",
    "    \"\"\"\n",
    "    Normalize model classification into one of the three\n",
    "    dissertation labels.\n",
    "    \"\"\"\n",
    "\n",
    "    if value is None:\n",
    "        return None\n",
    "\n",
    "    value = str(value).strip()\n",
    "\n",
    "    # Remove markdown/code formatting\n",
    "    value = value.replace(\"`\", \"\").strip()\n",
    "\n",
    "    # Normalize common variations\n",
    "    normalized = re.sub(r\"\\s+\", \" \", value).strip().lower()\n",
    "\n",
    "    mapping = {\n",
    "        \"reliable/supported\": \"Reliable/Supported\",\n",
    "        \"reliable / supported\": \"Reliable/Supported\",\n",
    "        \"reliable\": \"Reliable/Supported\",\n",
    "        \"supported\": \"Reliable/Supported\",\n",
    "\n",
    "        \"misleading/false\": \"Misleading/False\",\n",
    "        \"misleading / false\": \"Misleading/False\",\n",
    "        \"misleading\": \"Misleading/False\",\n",
    "        \"false\": \"Misleading/False\",\n",
    "\n",
    "        \"unverified\": \"Unverified\",\n",
    "        \"unknown\": \"Unverified\",\n",
    "        \"uncertain\": \"Unverified\"\n",
    "    }\n",
    "\n",
    "    return mapping.get(normalized)\n",
    "\n",
    "\n",
    "def parse_llm_json(text):\n",
    "    \"\"\"\n",
    "    Robustly extract the model's JSON response.\n",
    "    Handles normal JSON, markdown code blocks and\n",
    "    minor formatting variations.\n",
    "    \"\"\"\n",
    "\n",
    "    if not text:\n",
    "        return None\n",
    "\n",
    "    text = str(text).strip()\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # 1. Try complete response as JSON\n",
    "    # --------------------------------------------------------\n",
    "    try:\n",
    "        obj = json.loads(text)\n",
    "\n",
    "        if isinstance(obj, dict):\n",
    "            return obj\n",
    "\n",
    "    except Exception:\n",
    "        pass\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # 2. Remove markdown code fences\n",
    "    # --------------------------------------------------------\n",
    "    cleaned = re.sub(\n",
    "        r\"```(?:json)?\",\n",
    "        \"\",\n",
    "        text,\n",
    "        flags=re.IGNORECASE\n",
    "    )\n",
    "\n",
    "    cleaned = cleaned.replace(\"```\", \"\").strip()\n",
    "\n",
    "    try:\n",
    "        obj = json.loads(cleaned)\n",
    "\n",
    "        if isinstance(obj, dict):\n",
    "            return obj\n",
    "\n",
    "    except Exception:\n",
    "        pass\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # 3. Search for a JSON object\n",
    "    # --------------------------------------------------------\n",
    "    matches = re.findall(\n",
    "        r\"\\{.*?\\}\",\n",
    "        text,\n",
    "        flags=re.DOTALL\n",
    "    )\n",
    "\n",
    "    for candidate in matches:\n",
    "\n",
    "        try:\n",
    "            obj = json.loads(candidate)\n",
    "\n",
    "            if isinstance(obj, dict):\n",
    "                return obj\n",
    "\n",
    "        except Exception:\n",
    "            continue\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # 4. Last-resort extraction of classification\n",
    "    # --------------------------------------------------------\n",
    "    classification_match = re.search(\n",
    "        r'\"classification\"\\s*:\\s*\"([^\"]+)\"',\n",
    "        text,\n",
    "        flags=re.IGNORECASE\n",
    "    )\n",
    "\n",
    "    explanation_match = re.search(\n",
    "        r'\"explanation\"\\s*:\\s*\"([^\"]*)\"',\n",
    "        text,\n",
    "        flags=re.IGNORECASE\n",
    "    )\n",
    "\n",
    "    if classification_match:\n",
    "\n",
    "        return {\n",
    "            \"classification\": classification_match.group(1),\n",
    "            \"explanation\": (\n",
    "                explanation_match.group(1)\n",
    "                if explanation_match\n",
    "                else \"\"\n",
    "            )\n",
    "        }\n",
    "\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "a5ddf9d5-224c-4db9-9605-49165481a69a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def call_llm_with_retry(\n",
    "    client,\n",
    "    claim,\n",
    "    prompt_type,\n",
    "    run_number,\n",
    "    max_retries=5\n",
    "):\n",
    "\n",
    "    last_error = None\n",
    "\n",
    "    for attempt in range(max_retries):\n",
    "\n",
    "        try:\n",
    "\n",
    "            return call_llm(\n",
    "                client=client,\n",
    "                claim=claim,\n",
    "                prompt_type=prompt_type,\n",
    "                run_number=run_number\n",
    "            )\n",
    "\n",
    "        except Exception as e:\n",
    "\n",
    "            last_error = e\n",
    "\n",
    "            print(\n",
    "                f\"Attempt {attempt + 1}/{max_retries} failed: \"\n",
    "                f\"{type(e).__name__}: {e}\"\n",
    "            )\n",
    "\n",
    "            if attempt < max_retries - 1:\n",
    "\n",
    "                wait_seconds = min(\n",
    "                    2 ** attempt,\n",
    "                    30\n",
    "                )\n",
    "\n",
    "                print(\n",
    "                    f\"Waiting {wait_seconds} seconds...\"\n",
    "                )\n",
    "\n",
    "                time.sleep(wait_seconds)\n",
    "\n",
    "            else:\n",
    "                raise last_error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a73da35b",
   "metadata": {},
   "source": [
    "## 19. Pilot experiment — 15 API calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "1bb8ad75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "08490f94ef614212b96f9a7a37baa73a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Pilot:   0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attempt 1/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa5308d-45e6347952bf615a02224742;148f1842-ea88-4699-9cd5-e881b60f3f46)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 1 seconds...\n",
      "Attempt 2/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa5308e-12f58d4e5226b6b133f9d62f;4247bb17-6344-41b2-8f03-48d788d71406)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 2 seconds...\n",
      "Attempt 3/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa53090-5de6fc8c779c6df6221d9cca;f4d05160-2d84-4291-a79d-d6e0e9806964)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 4 seconds...\n",
      "Attempt 4/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa53095-3c21006674815c3b37fc95cb;eb160a88-f740-4214-a4c2-d5d4594a2db9)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 8 seconds...\n",
      "Attempt 5/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa5309d-08d31bf9566e7a3f1e0960d0;3acfe969-2ebe-493f-a792-b9a19b88b507)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Attempt 1/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa5309d-46b67e7614f9f71e7aa0acbc;813894eb-bd8d-485d-9f7d-35d7337f00bf)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 1 seconds...\n",
      "Attempt 2/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa5309f-705298254c8d45ce7b529614;36ea0f6a-f505-476e-9990-0d123d2847c3)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 2 seconds...\n",
      "Attempt 3/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa530a1-409222a00d3e4f5b4f11638b;20fafb63-ce69-4dd9-ab49-a29b2ecaedae)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 4 seconds...\n",
      "Attempt 4/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa530a5-2784b2743464d6d926cb5922;b2a513a5-b28c-4eec-bd81-66b7752205bb)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 8 seconds...\n",
      "Attempt 5/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa530ad-14d5cc034028aa7c273ab186;e743a9b5-fdd9-4029-8ad6-b0ea6b28dd8f)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Attempt 1/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa530ae-5443e3755b3e963347dbccc4;bf7ab36b-d75b-4fd9-85e0-41ab1a2dcf37)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 1 seconds...\n",
      "Attempt 2/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa530af-0f15191077422f1b04880524;f22c3d7a-28e5-4bf5-864c-3d788e01654b)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 2 seconds...\n",
      "Attempt 3/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa530b1-2e313a74154300582222b8e2;2b342a64-b72e-4f81-82a7-ae8fc3b3dbd7)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 4 seconds...\n",
      "Attempt 4/5 failed: HfHubHTTPError: Client error '402 Payment Required' for url 'https://router.huggingface.co/v1/chat/completions' (Request ID: Root=1-6aa530b5-52b9116469827f9506c74042;a4264bdc-5d85-4ca3-94bd-c898ba9d04cc)\n",
      "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402\n",
      "\n",
      "You have depleted your monthly included credits. Purchase pre-paid credits to continue using Inference Providers. Alternatively, subscribe to PRO to get 20x more included usage.\n",
      "Waiting 8 seconds...\n",
      "Pilot shape: (15, 17)\n",
      "Pilot saved to: D:\\PHEME_PLUS\\chapter4_outputs\\PHEMEPlus_LLM_Pilot_Results_v2.csv\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>prompt_type</th>\n",
       "      <th>ground_truth</th>\n",
       "      <th>prediction</th>\n",
       "      <th>response_time_seconds</th>\n",
       "      <th>explanation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Zero-Shot</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Misleading/False</td>\n",
       "      <td>0.543119</td>\n",
       "      <td>No credible evidence or reputable reports conf...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Definition-Based</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.540176</td>\n",
       "      <td>No reliable sources confirm that U.S. agencies...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Few-Shot</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.628261</td>\n",
       "      <td>There is no verifiable evidence from reliable ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Zero-Shot</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>INVALID_LABEL</td>\n",
       "      <td>0.577127</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Definition-Based</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.797485</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Few-Shot</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.617388</td>\n",
       "      <td>No verifiable records or widely reported news ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Zero-Shot</td>\n",
       "      <td>Misleading/False</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.714128</td>\n",
       "      <td>There is insufficient publicly available evide...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Definition-Based</td>\n",
       "      <td>Misleading/False</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>0.622844</td>\n",
       "      <td>Multiple reputable news outlets reported that ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Few-Shot</td>\n",
       "      <td>Misleading/False</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.609936</td>\n",
       "      <td>There is no clear, verifiable evidence confirm...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Zero-Shot</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>API_ERROR</td>\n",
       "      <td>NaN</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Definition-Based</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>API_ERROR</td>\n",
       "      <td>NaN</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Few-Shot</td>\n",
       "      <td>Reliable/Supported</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.658054</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Zero-Shot</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>1.320832</td>\n",
       "      <td>No reliable sources confirm the existence of s...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Definition-Based</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.499594</td>\n",
       "      <td>No credible evidence or reliable reporting con...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>Few-Shot</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>Unverified</td>\n",
       "      <td>0.591976</td>\n",
       "      <td>There is no publicly available, verifiable evi...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         prompt_type        ground_truth          prediction  \\\n",
       "0          Zero-Shot          Unverified    Misleading/False   \n",
       "1   Definition-Based          Unverified          Unverified   \n",
       "2           Few-Shot          Unverified          Unverified   \n",
       "3          Zero-Shot          Unverified       INVALID_LABEL   \n",
       "4   Definition-Based          Unverified          Unverified   \n",
       "5           Few-Shot          Unverified          Unverified   \n",
       "6          Zero-Shot    Misleading/False          Unverified   \n",
       "7   Definition-Based    Misleading/False  Reliable/Supported   \n",
       "8           Few-Shot    Misleading/False          Unverified   \n",
       "9          Zero-Shot  Reliable/Supported           API_ERROR   \n",
       "10  Definition-Based  Reliable/Supported           API_ERROR   \n",
       "11          Few-Shot  Reliable/Supported          Unverified   \n",
       "12         Zero-Shot          Unverified          Unverified   \n",
       "13  Definition-Based          Unverified          Unverified   \n",
       "14          Few-Shot          Unverified          Unverified   \n",
       "\n",
       "    response_time_seconds                                        explanation  \n",
       "0                0.543119  No credible evidence or reputable reports conf...  \n",
       "1                0.540176  No reliable sources confirm that U.S. agencies...  \n",
       "2                0.628261  There is no verifiable evidence from reliable ...  \n",
       "3                0.577127                                                     \n",
       "4                0.797485                                                     \n",
       "5                0.617388  No verifiable records or widely reported news ...  \n",
       "6                0.714128  There is insufficient publicly available evide...  \n",
       "7                0.622844  Multiple reputable news outlets reported that ...  \n",
       "8                0.609936  There is no clear, verifiable evidence confirm...  \n",
       "9                     NaN                                                     \n",
       "10                    NaN                                                     \n",
       "11               0.658054                                                     \n",
       "12               1.320832  No reliable sources confirm the existence of s...  \n",
       "13               0.499594  No credible evidence or reliable reporting con...  \n",
       "14               0.591976  There is no publicly available, verifiable evi...  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ============================================================\n",
    "# 19. RUN CONTROLLED PILOT EXPERIMENT\n",
    "# ============================================================\n",
    "\n",
    "PILOT_N = min(5, len(experiment_df))\n",
    "\n",
    "pilot_results = []\n",
    "\n",
    "for _, row in tqdm(\n",
    "    experiment_df.head(PILOT_N).iterrows(),\n",
    "    total=PILOT_N,\n",
    "    desc=\"Pilot\"\n",
    "):\n",
    "\n",
    "    for prompt_type in PROMPT_TYPES:\n",
    "\n",
    "        try:\n",
    "\n",
    "            result = call_llm_with_retry(\n",
    "                client=client,\n",
    "                claim=row[\"source_text\"],\n",
    "                prompt_type=prompt_type,\n",
    "                run_number=1,\n",
    "                max_retries=5\n",
    "            )\n",
    "\n",
    "            result.update({\n",
    "                \"event\": row[\"event\"],\n",
    "                \"thread_id\": row[\"thread_id\"],\n",
    "                \"tweet_id\": row[\"tweet_id\"],\n",
    "                \"ground_truth\": row[\"research_label\"],\n",
    "                \"claim\": row[\"claim\"],\n",
    "                \"source_text\": row[\"source_text\"]\n",
    "            })\n",
    "\n",
    "            pilot_results.append(result)\n",
    "\n",
    "        except Exception as e:\n",
    "\n",
    "            pilot_results.append({\n",
    "\n",
    "                \"model\": MODEL_NAME,\n",
    "                \"provider\": HF_PROVIDER,\n",
    "\n",
    "                \"prompt_type\": prompt_type,\n",
    "                \"run\": 1,\n",
    "\n",
    "                \"prediction\": \"API_ERROR\",\n",
    "                \"explanation\": \"\",\n",
    "\n",
    "                \"response_time_seconds\": np.nan,\n",
    "                \"raw_response\": \"\",\n",
    "\n",
    "                \"experiment_timestamp\":\n",
    "                    datetime.now().isoformat(\n",
    "                        timespec=\"seconds\"\n",
    "                    ),\n",
    "\n",
    "                \"event\": row[\"event\"],\n",
    "                \"thread_id\": row[\"thread_id\"],\n",
    "                \"tweet_id\": row[\"tweet_id\"],\n",
    "\n",
    "                \"ground_truth\":\n",
    "                    row[\"research_label\"],\n",
    "\n",
    "                \"claim\":\n",
    "                    row[\"claim\"],\n",
    "\n",
    "                \"source_text\":\n",
    "                    row[\"source_text\"],\n",
    "\n",
    "                \"error_type\":\n",
    "                    type(e).__name__,\n",
    "\n",
    "                \"error_message\":\n",
    "                    str(e)\n",
    "            })\n",
    "\n",
    "\n",
    "# ------------------------------------------------------------\n",
    "# Convert results to DataFrame\n",
    "# ------------------------------------------------------------\n",
    "\n",
    "pilot_results_df = pd.DataFrame(\n",
    "    pilot_results\n",
    ")\n",
    "\n",
    "\n",
    "# ------------------------------------------------------------\n",
    "# Save pilot results\n",
    "# ------------------------------------------------------------\n",
    "\n",
    "pilot_path = (\n",
    "    OUTPUT_DIR /\n",
    "    \"PHEMEPlus_LLM_Pilot_Results_v2.csv\"\n",
    ")\n",
    "\n",
    "pilot_results_df.to_csv(\n",
    "    pilot_path,\n",
    "    index=False,\n",
    "    encoding=\"utf-8-sig\"\n",
    ")\n",
    "\n",
    "\n",
    "# ------------------------------------------------------------\n",
    "# Display results\n",
    "# ------------------------------------------------------------\n",
    "\n",
    "print(\n",
    "    \"Pilot shape:\",\n",
    "    pilot_results_df.shape\n",
    ")\n",
    "\n",
    "print(\n",
    "    \"Pilot saved to:\",\n",
    "    pilot_path\n",
    ")\n",
    "\n",
    "display(\n",
    "    pilot_results_df[\n",
    "        [\n",
    "            \"prompt_type\",\n",
    "            \"ground_truth\",\n",
    "            \"prediction\",\n",
    "            \"response_time_seconds\",\n",
    "            \"explanation\"\n",
    "        ]\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1307dfce",
   "metadata": {},
   "source": [
    "## 20. Pilot validation — stop here if there are errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "d5c30aba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid / API / parse outputs: 3\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>count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Unverified</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>API_ERROR</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Misleading/False</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>INVALID_LABEL</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Reliable/Supported</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    count\n",
       "prediction               \n",
       "Unverified             10\n",
       "API_ERROR               2\n",
       "Misleading/False        1\n",
       "INVALID_LABEL           1\n",
       "Reliable/Supported      1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>prompt_type</th>\n",
       "      <th>prediction</th>\n",
       "      <th>raw_response</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Zero-Shot</td>\n",
       "      <td>INVALID_LABEL</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Zero-Shot</td>\n",
       "      <td>API_ERROR</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Definition-Based</td>\n",
       "      <td>API_ERROR</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         prompt_type     prediction raw_response\n",
       "3          Zero-Shot  INVALID_LABEL             \n",
       "9          Zero-Shot      API_ERROR             \n",
       "10  Definition-Based      API_ERROR             "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Expected valid labels:\n",
      "['Reliable/Supported', 'Misleading/False', 'Unverified']\n"
     ]
    }
   ],
   "source": [
    "invalid = ~pilot_results_df[\"prediction\"].isin(LABELS)\n",
    "\n",
    "print(\"Invalid / API / parse outputs:\", invalid.sum())\n",
    "display(\n",
    "    pilot_results_df[\"prediction\"]\n",
    "    .value_counts(dropna=False)\n",
    "    .to_frame(\"count\")\n",
    ")\n",
    "\n",
    "if invalid.any():\n",
    "    display(\n",
    "        pilot_results_df.loc[\n",
    "            invalid,\n",
    "            [\"prompt_type\", \"prediction\", \"raw_response\"]\n",
    "        ]\n",
    "    )\n",
    "\n",
    "print(\"\\nExpected valid labels:\")\n",
    "print(LABELS)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1f1bc59",
   "metadata": {},
   "source": [
    "## 21. Enable the full experiment\n",
    "\n",
    "After the pilot produces valid labels, change the following:\n",
    "\n",
    "```python\n",
    "RUN_FULL_EXPERIMENT = True\n",
    "```\n",
    "\n",
    "Then run this cell.\n",
    "\n",
    "With 100 claims per class, 3 prompts and 3 runs:\n",
    "\n",
    "**300 claims × 3 prompts × 3 runs = 2,700 API calls.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "3663234e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUN_FULL_EXPERIMENT = True\n"
     ]
    }
   ],
   "source": [
    "RUN_FULL_EXPERIMENT = True\n",
    "\n",
    "print(\"RUN_FULL_EXPERIMENT =\", RUN_FULL_EXPERIMENT)\n",
    "\n",
    "if not RUN_FULL_EXPERIMENT:\n",
    "    print(\"Full experiment is OFF. Change it to True after validating the pilot.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6350345",
   "metadata": {},
   "source": [
    "## 22. Full repeated experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "7ed20c37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "46752faff4fb4adb92b451ba351098b7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Full experiment:   0%|          | 0/300 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[99], line 16\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m run_number \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, REPEATS \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m):\n\u001b[0;32m     15\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m---> 16\u001b[0m         result \u001b[38;5;241m=\u001b[39m call_llm(\n\u001b[0;32m     17\u001b[0m             client,\n\u001b[0;32m     18\u001b[0m             row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msource_text\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[0;32m     19\u001b[0m             prompt_type,\n\u001b[0;32m     20\u001b[0m             run_number\n\u001b[0;32m     21\u001b[0m         )\n\u001b[0;32m     23\u001b[0m         result\u001b[38;5;241m.\u001b[39mupdate({\n\u001b[0;32m     24\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mevent\u001b[39m\u001b[38;5;124m\"\u001b[39m: row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mevent\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[0;32m     25\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthread_id\u001b[39m\u001b[38;5;124m\"\u001b[39m: row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthread_id\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     29\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msource_text\u001b[39m\u001b[38;5;124m\"\u001b[39m: row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msource_text\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m     30\u001b[0m         })\n\u001b[0;32m     32\u001b[0m         results\u001b[38;5;241m.\u001b[39mappend(result)\n",
      "Cell \u001b[1;32mIn[61], line 32\u001b[0m, in \u001b[0;36mcall_llm\u001b[1;34m(client, claim, prompt_type, run_number)\u001b[0m\n\u001b[0;32m     28\u001b[0m prompt \u001b[38;5;241m=\u001b[39m PROMPT_BUILDERS[prompt_type](claim)\n\u001b[0;32m     30\u001b[0m start \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m---> 32\u001b[0m response \u001b[38;5;241m=\u001b[39m client\u001b[38;5;241m.\u001b[39mchat\u001b[38;5;241m.\u001b[39mcompletions\u001b[38;5;241m.\u001b[39mcreate(\n\u001b[0;32m     33\u001b[0m     model\u001b[38;5;241m=\u001b[39mMODEL_NAME,\n\u001b[0;32m     34\u001b[0m     messages\u001b[38;5;241m=\u001b[39m[\n\u001b[0;32m     35\u001b[0m         {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrole\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msystem\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontent\u001b[39m\u001b[38;5;124m\"\u001b[39m: SYSTEM_INSTRUCTION},\n\u001b[0;32m     36\u001b[0m         {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrole\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124muser\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontent\u001b[39m\u001b[38;5;124m\"\u001b[39m: prompt}\n\u001b[0;32m     37\u001b[0m     ],\n\u001b[0;32m     38\u001b[0m     temperature\u001b[38;5;241m=\u001b[39mTEMPERATURE,\n\u001b[0;32m     39\u001b[0m     max_tokens\u001b[38;5;241m=\u001b[39mMAX_TOKENS\n\u001b[0;32m     40\u001b[0m )\n\u001b[0;32m     42\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter() \u001b[38;5;241m-\u001b[39m start\n\u001b[0;32m     44\u001b[0m raw_text \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m     45\u001b[0m     response\u001b[38;5;241m.\u001b[39mchoices[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mmessage\u001b[38;5;241m.\u001b[39mcontent\n\u001b[0;32m     46\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m response\u001b[38;5;241m.\u001b[39mchoices \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m     47\u001b[0m ) \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python312\\site-packages\\huggingface_hub\\inference\\_client.py:938\u001b[0m, in \u001b[0;36mInferenceClient.chat_completion\u001b[1;34m(self, messages, model, stream, frequency_penalty, logit_bias, logprobs, max_tokens, n, presence_penalty, response_format, seed, stop, stream_options, temperature, tool_choice, tool_prompt, tools, top_logprobs, top_p, extra_body)\u001b[0m\n\u001b[0;32m    910\u001b[0m parameters \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m    911\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel\u001b[39m\u001b[38;5;124m\"\u001b[39m: payload_model,\n\u001b[0;32m    912\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfrequency_penalty\u001b[39m\u001b[38;5;124m\"\u001b[39m: frequency_penalty,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    929\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m(extra_body \u001b[38;5;129;01mor\u001b[39;00m {}),\n\u001b[0;32m    930\u001b[0m }\n\u001b[0;32m    931\u001b[0m request_parameters \u001b[38;5;241m=\u001b[39m provider_helper\u001b[38;5;241m.\u001b[39mprepare_request(\n\u001b[0;32m    932\u001b[0m     inputs\u001b[38;5;241m=\u001b[39mmessages,\n\u001b[0;32m    933\u001b[0m     parameters\u001b[38;5;241m=\u001b[39mparameters,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    936\u001b[0m     api_key\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtoken,\n\u001b[0;32m    937\u001b[0m )\n\u001b[1;32m--> 938\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_inner_post(request_parameters, stream\u001b[38;5;241m=\u001b[39mstream)\n\u001b[0;32m    940\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m stream:\n\u001b[0;32m    941\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _stream_chat_completion_response(data)  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python312\\site-packages\\huggingface_hub\\inference\\_client.py:272\u001b[0m, in \u001b[0;36mInferenceClient._inner_post\u001b[1;34m(self, request_parameters, stream)\u001b[0m\n\u001b[0;32m    269\u001b[0m     request_parameters\u001b[38;5;241m.\u001b[39mheaders[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccept\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mimage/png\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    271\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 272\u001b[0m     response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexit_stack\u001b[38;5;241m.\u001b[39menter_context(\n\u001b[0;32m    273\u001b[0m         get_session()\u001b[38;5;241m.\u001b[39mstream(\n\u001b[0;32m    274\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPOST\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m    275\u001b[0m             request_parameters\u001b[38;5;241m.\u001b[39murl,\n\u001b[0;32m    276\u001b[0m             json\u001b[38;5;241m=\u001b[39mrequest_parameters\u001b[38;5;241m.\u001b[39mjson,\n\u001b[0;32m    277\u001b[0m             content\u001b[38;5;241m=\u001b[39mrequest_parameters\u001b[38;5;241m.\u001b[39mdata,\n\u001b[0;32m    278\u001b[0m             headers\u001b[38;5;241m=\u001b[39mrequest_parameters\u001b[38;5;241m.\u001b[39mheaders,\n\u001b[0;32m    279\u001b[0m             cookies\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcookies,\n\u001b[0;32m    280\u001b[0m             timeout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtimeout,\n\u001b[0;32m    281\u001b[0m         )\n\u001b[0;32m    282\u001b[0m     )\n\u001b[0;32m    283\u001b[0m     hf_raise_for_status(response)\n\u001b[0;32m    284\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m stream:\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\contextlib.py:526\u001b[0m, in \u001b[0;36m_BaseExitStack.enter_context\u001b[1;34m(self, cm)\u001b[0m\n\u001b[0;32m    523\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m:\n\u001b[0;32m    524\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__module__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m object does \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    525\u001b[0m                     \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnot support the context manager protocol\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m--> 526\u001b[0m result \u001b[38;5;241m=\u001b[39m _enter(cm)\n\u001b[0;32m    527\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_push_cm_exit(cm, _exit)\n\u001b[0;32m    528\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\contextlib.py:137\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__enter__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    135\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc\n\u001b[0;32m    136\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 137\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mnext\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgen)\n\u001b[0;32m    138\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[0;32m    139\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgenerator didn\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt yield\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpx\\_client.py:870\u001b[0m, in \u001b[0;36mClient.stream\u001b[1;34m(self, method, url, content, data, files, json, params, headers, cookies, auth, follow_redirects, timeout, extensions)\u001b[0m\n\u001b[0;32m    847\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    848\u001b[0m \u001b[38;5;124;03mAlternative to `httpx.request()` that streams the response body\u001b[39;00m\n\u001b[0;32m    849\u001b[0m \u001b[38;5;124;03minstead of loading it into memory at once.\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    855\u001b[0m \u001b[38;5;124;03m[0]: /quickstart#streaming-responses\u001b[39;00m\n\u001b[0;32m    856\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    857\u001b[0m request \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbuild_request(\n\u001b[0;32m    858\u001b[0m     method\u001b[38;5;241m=\u001b[39mmethod,\n\u001b[0;32m    859\u001b[0m     url\u001b[38;5;241m=\u001b[39murl,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    868\u001b[0m     extensions\u001b[38;5;241m=\u001b[39mextensions,\n\u001b[0;32m    869\u001b[0m )\n\u001b[1;32m--> 870\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msend(\n\u001b[0;32m    871\u001b[0m     request\u001b[38;5;241m=\u001b[39mrequest,\n\u001b[0;32m    872\u001b[0m     auth\u001b[38;5;241m=\u001b[39mauth,\n\u001b[0;32m    873\u001b[0m     follow_redirects\u001b[38;5;241m=\u001b[39mfollow_redirects,\n\u001b[0;32m    874\u001b[0m     stream\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m    875\u001b[0m )\n\u001b[0;32m    876\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m    877\u001b[0m     \u001b[38;5;28;01myield\u001b[39;00m response\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpx\\_client.py:914\u001b[0m, in \u001b[0;36mClient.send\u001b[1;34m(self, request, stream, auth, follow_redirects)\u001b[0m\n\u001b[0;32m    906\u001b[0m follow_redirects \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m    907\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfollow_redirects\n\u001b[0;32m    908\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(follow_redirects, UseClientDefault)\n\u001b[0;32m    909\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m follow_redirects\n\u001b[0;32m    910\u001b[0m )\n\u001b[0;32m    912\u001b[0m auth \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_build_request_auth(request, auth)\n\u001b[1;32m--> 914\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_send_handling_auth(\n\u001b[0;32m    915\u001b[0m     request,\n\u001b[0;32m    916\u001b[0m     auth\u001b[38;5;241m=\u001b[39mauth,\n\u001b[0;32m    917\u001b[0m     follow_redirects\u001b[38;5;241m=\u001b[39mfollow_redirects,\n\u001b[0;32m    918\u001b[0m     history\u001b[38;5;241m=\u001b[39m[],\n\u001b[0;32m    919\u001b[0m )\n\u001b[0;32m    920\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m    921\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m stream:\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpx\\_client.py:942\u001b[0m, in \u001b[0;36mClient._send_handling_auth\u001b[1;34m(self, request, auth, follow_redirects, history)\u001b[0m\n\u001b[0;32m    939\u001b[0m request \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mnext\u001b[39m(auth_flow)\n\u001b[0;32m    941\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m--> 942\u001b[0m     response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_send_handling_redirects(\n\u001b[0;32m    943\u001b[0m         request,\n\u001b[0;32m    944\u001b[0m         follow_redirects\u001b[38;5;241m=\u001b[39mfollow_redirects,\n\u001b[0;32m    945\u001b[0m         history\u001b[38;5;241m=\u001b[39mhistory,\n\u001b[0;32m    946\u001b[0m     )\n\u001b[0;32m    947\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m    948\u001b[0m         \u001b[38;5;28;01mtry\u001b[39;00m:\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpx\\_client.py:979\u001b[0m, in \u001b[0;36mClient._send_handling_redirects\u001b[1;34m(self, request, follow_redirects, history)\u001b[0m\n\u001b[0;32m    976\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m hook \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_event_hooks[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrequest\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n\u001b[0;32m    977\u001b[0m     hook(request)\n\u001b[1;32m--> 979\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_send_single_request(request)\n\u001b[0;32m    980\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m    981\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m hook \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_event_hooks[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mresponse\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpx\\_client.py:1015\u001b[0m, in \u001b[0;36mClient._send_single_request\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m   1010\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m   1011\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAttempted to send an async request with a sync Client instance.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1012\u001b[0m     )\n\u001b[0;32m   1014\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m request_context(request\u001b[38;5;241m=\u001b[39mrequest):\n\u001b[1;32m-> 1015\u001b[0m     response \u001b[38;5;241m=\u001b[39m transport\u001b[38;5;241m.\u001b[39mhandle_request(request)\n\u001b[0;32m   1017\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(response\u001b[38;5;241m.\u001b[39mstream, SyncByteStream)\n\u001b[0;32m   1019\u001b[0m response\u001b[38;5;241m.\u001b[39mrequest \u001b[38;5;241m=\u001b[39m request\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpx\\_transports\\default.py:233\u001b[0m, in \u001b[0;36mHTTPTransport.handle_request\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m    220\u001b[0m req \u001b[38;5;241m=\u001b[39m httpcore\u001b[38;5;241m.\u001b[39mRequest(\n\u001b[0;32m    221\u001b[0m     method\u001b[38;5;241m=\u001b[39mrequest\u001b[38;5;241m.\u001b[39mmethod,\n\u001b[0;32m    222\u001b[0m     url\u001b[38;5;241m=\u001b[39mhttpcore\u001b[38;5;241m.\u001b[39mURL(\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    230\u001b[0m     extensions\u001b[38;5;241m=\u001b[39mrequest\u001b[38;5;241m.\u001b[39mextensions,\n\u001b[0;32m    231\u001b[0m )\n\u001b[0;32m    232\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m map_httpcore_exceptions():\n\u001b[1;32m--> 233\u001b[0m     resp \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pool\u001b[38;5;241m.\u001b[39mhandle_request(req)\n\u001b[0;32m    235\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(resp\u001b[38;5;241m.\u001b[39mstream, typing\u001b[38;5;241m.\u001b[39mIterable)\n\u001b[0;32m    237\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m Response(\n\u001b[0;32m    238\u001b[0m     status_code\u001b[38;5;241m=\u001b[39mresp\u001b[38;5;241m.\u001b[39mstatus,\n\u001b[0;32m    239\u001b[0m     headers\u001b[38;5;241m=\u001b[39mresp\u001b[38;5;241m.\u001b[39mheaders,\n\u001b[0;32m    240\u001b[0m     stream\u001b[38;5;241m=\u001b[39mResponseStream(resp\u001b[38;5;241m.\u001b[39mstream),\n\u001b[0;32m    241\u001b[0m     extensions\u001b[38;5;241m=\u001b[39mresp\u001b[38;5;241m.\u001b[39mextensions,\n\u001b[0;32m    242\u001b[0m )\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_sync\\connection_pool.py:268\u001b[0m, in \u001b[0;36mConnectionPool.handle_request\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m    266\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ShieldCancellation():\n\u001b[0;32m    267\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresponse_closed(status)\n\u001b[1;32m--> 268\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[0;32m    269\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    270\u001b[0m     \u001b[38;5;28;01mbreak\u001b[39;00m\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_sync\\connection_pool.py:251\u001b[0m, in \u001b[0;36mConnectionPool.handle_request\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m    248\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[0;32m    250\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 251\u001b[0m     response \u001b[38;5;241m=\u001b[39m connection\u001b[38;5;241m.\u001b[39mhandle_request(request)\n\u001b[0;32m    252\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m ConnectionNotAvailable:\n\u001b[0;32m    253\u001b[0m     \u001b[38;5;66;03m# The ConnectionNotAvailable exception is a special case, that\u001b[39;00m\n\u001b[0;32m    254\u001b[0m     \u001b[38;5;66;03m# indicates we need to retry the request on a new connection.\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    258\u001b[0m     \u001b[38;5;66;03m# might end up as an HTTP/2 connection, but which actually ends\u001b[39;00m\n\u001b[0;32m    259\u001b[0m     \u001b[38;5;66;03m# up as HTTP/1.1.\u001b[39;00m\n\u001b[0;32m    260\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pool_lock:\n\u001b[0;32m    261\u001b[0m         \u001b[38;5;66;03m# Maintain our position in the request queue, but reset the\u001b[39;00m\n\u001b[0;32m    262\u001b[0m         \u001b[38;5;66;03m# status so that the request becomes queued again.\u001b[39;00m\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_sync\\connection.py:103\u001b[0m, in \u001b[0;36mHTTPConnection.handle_request\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m    100\u001b[0m     \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_connection\u001b[38;5;241m.\u001b[39mis_available():\n\u001b[0;32m    101\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m ConnectionNotAvailable()\n\u001b[1;32m--> 103\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_connection\u001b[38;5;241m.\u001b[39mhandle_request(request)\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_sync\\http11.py:133\u001b[0m, in \u001b[0;36mHTTP11Connection.handle_request\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m    131\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m Trace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mresponse_closed\u001b[39m\u001b[38;5;124m\"\u001b[39m, logger, request) \u001b[38;5;28;01mas\u001b[39;00m trace:\n\u001b[0;32m    132\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_response_closed()\n\u001b[1;32m--> 133\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_sync\\http11.py:111\u001b[0m, in \u001b[0;36mHTTP11Connection.handle_request\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m    101\u001b[0m     \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[0;32m    103\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m Trace(\n\u001b[0;32m    104\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreceive_response_headers\u001b[39m\u001b[38;5;124m\"\u001b[39m, logger, request, kwargs\n\u001b[0;32m    105\u001b[0m ) \u001b[38;5;28;01mas\u001b[39;00m trace:\n\u001b[0;32m    106\u001b[0m     (\n\u001b[0;32m    107\u001b[0m         http_version,\n\u001b[0;32m    108\u001b[0m         status,\n\u001b[0;32m    109\u001b[0m         reason_phrase,\n\u001b[0;32m    110\u001b[0m         headers,\n\u001b[1;32m--> 111\u001b[0m     ) \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_receive_response_headers(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    112\u001b[0m     trace\u001b[38;5;241m.\u001b[39mreturn_value \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m    113\u001b[0m         http_version,\n\u001b[0;32m    114\u001b[0m         status,\n\u001b[0;32m    115\u001b[0m         reason_phrase,\n\u001b[0;32m    116\u001b[0m         headers,\n\u001b[0;32m    117\u001b[0m     )\n\u001b[0;32m    119\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m Response(\n\u001b[0;32m    120\u001b[0m     status\u001b[38;5;241m=\u001b[39mstatus,\n\u001b[0;32m    121\u001b[0m     headers\u001b[38;5;241m=\u001b[39mheaders,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    127\u001b[0m     },\n\u001b[0;32m    128\u001b[0m )\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_sync\\http11.py:176\u001b[0m, in \u001b[0;36mHTTP11Connection._receive_response_headers\u001b[1;34m(self, request)\u001b[0m\n\u001b[0;32m    173\u001b[0m timeout \u001b[38;5;241m=\u001b[39m timeouts\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mread\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m    175\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m--> 176\u001b[0m     event \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_receive_event(timeout\u001b[38;5;241m=\u001b[39mtimeout)\n\u001b[0;32m    177\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(event, h11\u001b[38;5;241m.\u001b[39mResponse):\n\u001b[0;32m    178\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_sync\\http11.py:212\u001b[0m, in \u001b[0;36mHTTP11Connection._receive_event\u001b[1;34m(self, timeout)\u001b[0m\n\u001b[0;32m    209\u001b[0m     event \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_h11_state\u001b[38;5;241m.\u001b[39mnext_event()\n\u001b[0;32m    211\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m event \u001b[38;5;129;01mis\u001b[39;00m h11\u001b[38;5;241m.\u001b[39mNEED_DATA:\n\u001b[1;32m--> 212\u001b[0m     data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_network_stream\u001b[38;5;241m.\u001b[39mread(\n\u001b[0;32m    213\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mREAD_NUM_BYTES, timeout\u001b[38;5;241m=\u001b[39mtimeout\n\u001b[0;32m    214\u001b[0m     )\n\u001b[0;32m    216\u001b[0m     \u001b[38;5;66;03m# If we feed this case through h11 we'll raise an exception like:\u001b[39;00m\n\u001b[0;32m    217\u001b[0m     \u001b[38;5;66;03m#\u001b[39;00m\n\u001b[0;32m    218\u001b[0m     \u001b[38;5;66;03m#     httpcore.RemoteProtocolError: can't handle event type\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    222\u001b[0m     \u001b[38;5;66;03m# perspective. Instead we handle this case distinctly and treat\u001b[39;00m\n\u001b[0;32m    223\u001b[0m     \u001b[38;5;66;03m# it as a ConnectError.\u001b[39;00m\n\u001b[0;32m    224\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;241m==\u001b[39m \u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_h11_state\u001b[38;5;241m.\u001b[39mtheir_state \u001b[38;5;241m==\u001b[39m h11\u001b[38;5;241m.\u001b[39mSEND_RESPONSE:\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\httpcore\\_backends\\sync.py:126\u001b[0m, in \u001b[0;36mSyncStream.read\u001b[1;34m(self, max_bytes, timeout)\u001b[0m\n\u001b[0;32m    124\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m map_exceptions(exc_map):\n\u001b[0;32m    125\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sock\u001b[38;5;241m.\u001b[39msettimeout(timeout)\n\u001b[1;32m--> 126\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sock\u001b[38;5;241m.\u001b[39mrecv(max_bytes)\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\ssl.py:1232\u001b[0m, in \u001b[0;36mSSLSocket.recv\u001b[1;34m(self, buflen, flags)\u001b[0m\n\u001b[0;32m   1228\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m flags \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m   1229\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m   1230\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnon-zero flags not allowed in calls to recv() on \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m\n\u001b[0;32m   1231\u001b[0m             \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m)\n\u001b[1;32m-> 1232\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mread(buflen)\n\u001b[0;32m   1233\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   1234\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39mrecv(buflen, flags)\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\ssl.py:1105\u001b[0m, in \u001b[0;36mSSLSocket.read\u001b[1;34m(self, len, buffer)\u001b[0m\n\u001b[0;32m   1103\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sslobj\u001b[38;5;241m.\u001b[39mread(\u001b[38;5;28mlen\u001b[39m, buffer)\n\u001b[0;32m   1104\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1105\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sslobj\u001b[38;5;241m.\u001b[39mread(\u001b[38;5;28mlen\u001b[39m)\n\u001b[0;32m   1106\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m SSLError \u001b[38;5;28;01mas\u001b[39;00m x:\n\u001b[0;32m   1107\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m x\u001b[38;5;241m.\u001b[39margs[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m==\u001b[39m SSL_ERROR_EOF \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msuppress_ragged_eofs:\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    results = []\n",
    "\n",
    "    for _, row in tqdm(\n",
    "        experiment_df.iterrows(),\n",
    "        total=len(experiment_df),\n",
    "        desc=\"Full experiment\"\n",
    "    ):\n",
    "\n",
    "        for prompt_type in PROMPT_TYPES:\n",
    "\n",
    "            for run_number in range(1, REPEATS + 1):\n",
    "\n",
    "                try:\n",
    "                    result = call_llm(\n",
    "                        client,\n",
    "                        row[\"source_text\"],\n",
    "                        prompt_type,\n",
    "                        run_number\n",
    "                    )\n",
    "\n",
    "                    result.update({\n",
    "                        \"event\": row[\"event\"],\n",
    "                        \"thread_id\": row[\"thread_id\"],\n",
    "                        \"tweet_id\": row[\"tweet_id\"],\n",
    "                        \"ground_truth\": row[\"research_label\"],\n",
    "                        \"claim\": row[\"claim\"],\n",
    "                        \"source_text\": row[\"source_text\"]\n",
    "                    })\n",
    "\n",
    "                    results.append(result)\n",
    "\n",
    "                except Exception as e:\n",
    "                    results.append({\n",
    "                        \"model\": MODEL_NAME,\n",
    "                        \"provider\": HF_PROVIDER,\n",
    "                        \"prompt_type\": prompt_type,\n",
    "                        \"run\": run_number,\n",
    "                        \"prediction\": \"API_ERROR\",\n",
    "                        \"explanation\": \"\",\n",
    "                        \"response_time_seconds\": np.nan,\n",
    "                        \"raw_response\": \"\",\n",
    "                        \"experiment_timestamp\": datetime.now().isoformat(timespec=\"seconds\"),\n",
    "                        \"event\": row[\"event\"],\n",
    "                        \"thread_id\": row[\"thread_id\"],\n",
    "                        \"tweet_id\": row[\"tweet_id\"],\n",
    "                        \"ground_truth\": row[\"research_label\"],\n",
    "                        \"claim\": row[\"claim\"],\n",
    "                        \"source_text\": row[\"source_text\"],\n",
    "                        \"error_type\": type(e).__name__,\n",
    "                        \"error_message\": str(e)\n",
    "                    })\n",
    "\n",
    "    results_df = pd.DataFrame(results)\n",
    "\n",
    "    expected = len(experiment_df) * len(PROMPT_TYPES) * REPEATS\n",
    "\n",
    "    print(\"Expected rows:\", expected)\n",
    "    print(\"Actual rows:\", len(results_df))\n",
    "\n",
    "    results_path = OUTPUT_DIR / \"PHEMEPlus_LLM_Experiment_Results.csv\"\n",
    "\n",
    "    results_df.to_csv(\n",
    "        results_path,\n",
    "        index=False,\n",
    "        encoding=\"utf-8-sig\"\n",
    "    )\n",
    "\n",
    "    print(\"Saved:\", results_path)\n",
    "else:\n",
    "    print(\"Full experiment is OFF.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b2fc764",
   "metadata": {},
   "source": [
    "## 23. Aggregate repeated runs by modal prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6485b28f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mode_prediction(values):\n",
    "    valid = [x for x in values if x in LABELS]\n",
    "\n",
    "    if not valid:\n",
    "        return \"INVALID_LABEL\"\n",
    "\n",
    "    return pd.Series(valid).value_counts().index[0]\n",
    "\n",
    "\n",
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    rows = []\n",
    "\n",
    "    for (thread_id, prompt_type), group in results_df.groupby(\n",
    "        [\"thread_id\", \"prompt_type\"],\n",
    "        sort=False\n",
    "    ):\n",
    "\n",
    "        rows.append({\n",
    "            \"thread_id\": thread_id,\n",
    "            \"prompt_type\": prompt_type,\n",
    "            \"ground_truth\": group[\"ground_truth\"].iloc[0],\n",
    "            \"mode_prediction\": mode_prediction(group[\"prediction\"]),\n",
    "            \"mean_response_time_seconds\": group[\"response_time_seconds\"].mean(),\n",
    "            \"valid_run_count\": group[\"prediction\"].isin(LABELS).sum()\n",
    "        })\n",
    "\n",
    "    aggregated_df = pd.DataFrame(rows)\n",
    "    display(aggregated_df.head())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "454dbb10",
   "metadata": {},
   "source": [
    "## 24. Accuracy, Macro-Precision, Macro-Recall and Macro-F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77d93d6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_metrics(y_true, y_pred):\n",
    "    y_true = np.asarray(y_true)\n",
    "    y_pred = np.asarray(y_pred)\n",
    "\n",
    "    valid = np.isin(y_pred, LABELS)\n",
    "\n",
    "    yt = y_true[valid]\n",
    "    yp = y_pred[valid]\n",
    "\n",
    "    if len(yt) == 0:\n",
    "        return {\n",
    "            \"Accuracy\": np.nan,\n",
    "            \"Macro-Precision\": np.nan,\n",
    "            \"Macro-Recall\": np.nan,\n",
    "            \"Macro-F1\": np.nan,\n",
    "            \"Invalid Rate\": 1.0\n",
    "        }\n",
    "\n",
    "    p, r, f1, _ = precision_recall_fscore_support(\n",
    "        yt, yp,\n",
    "        labels=LABELS,\n",
    "        average=\"macro\",\n",
    "        zero_division=0\n",
    "    )\n",
    "\n",
    "    return {\n",
    "        \"Accuracy\": accuracy_score(yt, yp),\n",
    "        \"Macro-Precision\": p,\n",
    "        \"Macro-Recall\": r,\n",
    "        \"Macro-F1\": f1,\n",
    "        \"Invalid Rate\": 1 - len(yt) / len(y_true)\n",
    "    }\n",
    "\n",
    "\n",
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    metric_rows = []\n",
    "\n",
    "    for prompt_type, group in aggregated_df.groupby(\"prompt_type\"):\n",
    "        row = calculate_metrics(\n",
    "            group[\"ground_truth\"],\n",
    "            group[\"mode_prediction\"]\n",
    "        )\n",
    "        row[\"Prompt Type\"] = prompt_type\n",
    "        metric_rows.append(row)\n",
    "\n",
    "    metrics_df = pd.DataFrame(\n",
    "        metric_rows\n",
    "    ).set_index(\"Prompt Type\")\n",
    "\n",
    "    display(metrics_df.round(4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "596a4beb",
   "metadata": {},
   "source": [
    "## 25. Class-level metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbfc6c75",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    rows = []\n",
    "\n",
    "    for prompt_type, group in aggregated_df.groupby(\"prompt_type\"):\n",
    "\n",
    "        valid = group[\"mode_prediction\"].isin(LABELS)\n",
    "\n",
    "        p, r, f, support = precision_recall_fscore_support(\n",
    "            group.loc[valid, \"ground_truth\"],\n",
    "            group.loc[valid, \"mode_prediction\"],\n",
    "            labels=LABELS,\n",
    "            zero_division=0\n",
    "        )\n",
    "\n",
    "        for label, pp, rr, ff, ss in zip(\n",
    "            LABELS, p, r, f, support\n",
    "        ):\n",
    "            rows.append({\n",
    "                \"Prompt Type\": prompt_type,\n",
    "                \"Class\": label,\n",
    "                \"Precision\": pp,\n",
    "                \"Recall\": rr,\n",
    "                \"F1\": ff,\n",
    "                \"Support\": ss\n",
    "            })\n",
    "\n",
    "    class_metrics_df = pd.DataFrame(rows)\n",
    "    display(class_metrics_df.round(4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b92090e3",
   "metadata": {},
   "source": [
    "## 26. FP and FN rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13d85a8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    rows = []\n",
    "\n",
    "    for prompt_type, group in aggregated_df.groupby(\"prompt_type\"):\n",
    "\n",
    "        valid = group[\"mode_prediction\"].isin(LABELS)\n",
    "\n",
    "        cm = confusion_matrix(\n",
    "            group.loc[valid, \"ground_truth\"],\n",
    "            group.loc[valid, \"mode_prediction\"],\n",
    "            labels=LABELS\n",
    "        )\n",
    "\n",
    "        for i, label in enumerate(LABELS):\n",
    "\n",
    "            tp = cm[i, i]\n",
    "            fn = cm[i, :].sum() - tp\n",
    "            fp = cm[:, i].sum() - tp\n",
    "            tn = cm.sum() - tp - fn - fp\n",
    "\n",
    "            rows.append({\n",
    "                \"Prompt Type\": prompt_type,\n",
    "                \"Class\": label,\n",
    "                \"FP Rate\": fp / (fp + tn) if fp + tn else np.nan,\n",
    "                \"FN Rate\": fn / (fn + tp) if fn + tp else np.nan\n",
    "            })\n",
    "\n",
    "    error_rates_df = pd.DataFrame(rows)\n",
    "    display(error_rates_df.round(4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57160c11",
   "metadata": {},
   "source": [
    "## 27. Confusion matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa15e408",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    for prompt_type in PROMPT_TYPES:\n",
    "\n",
    "        group = aggregated_df[\n",
    "            aggregated_df[\"prompt_type\"] == prompt_type\n",
    "        ]\n",
    "\n",
    "        valid = group[\"mode_prediction\"].isin(LABELS)\n",
    "\n",
    "        cm = confusion_matrix(\n",
    "            group.loc[valid, \"ground_truth\"],\n",
    "            group.loc[valid, \"mode_prediction\"],\n",
    "            labels=LABELS\n",
    "        )\n",
    "\n",
    "        plt.figure(figsize=(7,6))\n",
    "\n",
    "        sns.heatmap(\n",
    "            cm,\n",
    "            annot=True,\n",
    "            fmt=\"d\",\n",
    "            cmap=\"Blues\",\n",
    "            xticklabels=LABELS,\n",
    "            yticklabels=LABELS\n",
    "        )\n",
    "\n",
    "        plt.title(f\"Confusion Matrix — {prompt_type}\")\n",
    "        plt.xlabel(\"Predicted\")\n",
    "        plt.ylabel(\"Actual\")\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "506190b0",
   "metadata": {},
   "source": [
    "## 28. Figure 4.5 — Prompt performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34e91be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    metrics_df[\n",
    "        [\"Accuracy\", \"Macro-F1\", \"Macro-Precision\", \"Macro-Recall\"]\n",
    "    ].plot(kind=\"bar\", figsize=(11,6))\n",
    "\n",
    "    plt.title(\"Figure 4.5: Performance Comparison Across Prompting Conditions\")\n",
    "    plt.xlabel(\"Prompting condition\")\n",
    "    plt.ylabel(\"Score\")\n",
    "    plt.ylim(0,1)\n",
    "    plt.xticks(rotation=0)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "786aef6e",
   "metadata": {},
   "source": [
    "## 29. Repeated-run agreement and Cohen's kappa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "526abc65",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    rows = []\n",
    "\n",
    "    for (thread_id, prompt_type), group in results_df.groupby(\n",
    "        [\"thread_id\", \"prompt_type\"],\n",
    "        sort=False\n",
    "    ):\n",
    "\n",
    "        mode = mode_prediction(group[\"prediction\"])\n",
    "\n",
    "        valid_preds = group.loc[\n",
    "            group[\"prediction\"].isin(LABELS),\n",
    "            \"prediction\"\n",
    "        ].tolist()\n",
    "\n",
    "        if valid_preds:\n",
    "            agreement = np.mean([p == mode for p in valid_preds])\n",
    "            kappa = cohen_kappa_score(\n",
    "                [mode] * len(valid_preds),\n",
    "                valid_preds,\n",
    "                labels=LABELS\n",
    "            )\n",
    "        else:\n",
    "            agreement = np.nan\n",
    "            kappa = np.nan\n",
    "\n",
    "        rows.append({\n",
    "            \"thread_id\": thread_id,\n",
    "            \"prompt_type\": prompt_type,\n",
    "            \"mode_prediction\": mode,\n",
    "            \"agreement_with_mode\": agreement,\n",
    "            \"cohen_kappa_vs_mode\": kappa\n",
    "        })\n",
    "\n",
    "    consistency_df = pd.DataFrame(rows)\n",
    "\n",
    "    consistency_summary = consistency_df.groupby(\n",
    "        \"prompt_type\"\n",
    "    ).agg(\n",
    "        Mean_Agreement=(\"agreement_with_mode\", \"mean\"),\n",
    "        Mean_Kappa=(\"cohen_kappa_vs_mode\", \"mean\")\n",
    "    )\n",
    "\n",
    "    display(consistency_summary.round(4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f84675d0",
   "metadata": {},
   "source": [
    "## 30. Figure 4.7 — Repeated-run agreement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbd47bf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    consistency_summary[\"Mean_Agreement\"].plot(\n",
    "        kind=\"bar\", figsize=(9,5)\n",
    "    )\n",
    "\n",
    "    plt.title(\"Figure 4.7: Repeated-Run Agreement by Prompting Condition\")\n",
    "    plt.xlabel(\"Prompting condition\")\n",
    "    plt.ylabel(\"Mean agreement with modal prediction\")\n",
    "    plt.ylim(0,1)\n",
    "    plt.xticks(rotation=0)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aa222a2",
   "metadata": {},
   "source": [
    "## 31. Figure 4.8 — Response time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dcfee48",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    response_summary = results_df.groupby(\n",
    "        \"prompt_type\"\n",
    "    )[\"response_time_seconds\"].agg(\n",
    "        [\"mean\", \"median\", \"std\"]\n",
    "    )\n",
    "\n",
    "    response_summary[\"mean\"].plot(\n",
    "        kind=\"bar\", figsize=(9,5)\n",
    "    )\n",
    "\n",
    "    plt.title(\"Figure 4.8: Mean Response Time by Prompting Condition\")\n",
    "    plt.xlabel(\"Prompting condition\")\n",
    "    plt.ylabel(\"Mean response time (seconds)\")\n",
    "    plt.xticks(rotation=0)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "    display(response_summary.round(3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7a2c4b8",
   "metadata": {},
   "source": [
    "## 32. Unverified-class analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c638bd65",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    rows = []\n",
    "\n",
    "    for prompt_type, group in aggregated_df.groupby(\"prompt_type\"):\n",
    "\n",
    "        valid = group[\"mode_prediction\"].isin(LABELS)\n",
    "\n",
    "        yt = group.loc[valid, \"ground_truth\"]\n",
    "        yp = group.loc[valid, \"mode_prediction\"]\n",
    "\n",
    "        true_u = yt == \"Unverified\"\n",
    "        pred_u = yp == \"Unverified\"\n",
    "\n",
    "        denominator = true_u.sum()\n",
    "\n",
    "        rows.append({\n",
    "            \"Prompt Type\": prompt_type,\n",
    "            \"Unverified Recall\": (\n",
    "                (true_u & pred_u).sum() / denominator\n",
    "                if denominator else np.nan\n",
    "            ),\n",
    "            \"Forced Classification Rate\": (\n",
    "                (true_u & ~pred_u).sum() / denominator\n",
    "                if denominator else np.nan\n",
    "            )\n",
    "        })\n",
    "\n",
    "    unverified_df = pd.DataFrame(rows).set_index(\"Prompt Type\")\n",
    "    display(unverified_df.round(4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd012ae5",
   "metadata": {},
   "source": [
    "## 33. Prompt sensitivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9c45410",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    wide = aggregated_df.pivot(\n",
    "        index=\"thread_id\",\n",
    "        columns=\"prompt_type\",\n",
    "        values=\"mode_prediction\"\n",
    "    )\n",
    "\n",
    "    wide[\"prompt_sensitive\"] = (\n",
    "        wide[PROMPT_TYPES].nunique(axis=1, dropna=True) > 1\n",
    "    )\n",
    "\n",
    "    print(\n",
    "        \"Overall prompt sensitivity:\",\n",
    "        round(wide[\"prompt_sensitive\"].mean(), 4)\n",
    "    )\n",
    "\n",
    "    pair_rows = []\n",
    "\n",
    "    for i, p1 in enumerate(PROMPT_TYPES):\n",
    "        for p2 in PROMPT_TYPES[i+1:]:\n",
    "            pair = wide[[p1, p2]].dropna()\n",
    "\n",
    "            pair_rows.append({\n",
    "                \"Comparison\": f\"{p1} vs {p2}\",\n",
    "                \"Sensitivity Rate\": (\n",
    "                    pair[p1] != pair[p2]\n",
    "                ).mean()\n",
    "            })\n",
    "\n",
    "    sensitivity_df = pd.DataFrame(pair_rows)\n",
    "    display(sensitivity_df.round(4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92ed4e8d",
   "metadata": {},
   "source": [
    "## 34. Error categories and high-risk errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd400db8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def error_category(row):\n",
    "\n",
    "    gt = row[\"ground_truth\"]\n",
    "    pred = row[\"mode_prediction\"]\n",
    "\n",
    "    if gt == pred:\n",
    "        return \"Correct\"\n",
    "\n",
    "    if gt == \"Misleading/False\" and pred == \"Reliable/Supported\":\n",
    "        return \"False claim accepted as reliable\"\n",
    "\n",
    "    if gt == \"Reliable/Supported\" and pred == \"Misleading/False\":\n",
    "        return \"True claim rejected as false\"\n",
    "\n",
    "    if gt == \"Unverified\" and pred != \"Unverified\":\n",
    "        return \"Unverified claim forced into truth/falsehood\"\n",
    "\n",
    "    if pred == \"Unverified\" and gt != \"Unverified\":\n",
    "        return \"Known claim classified as unverified\"\n",
    "\n",
    "    return \"Other classification error\"\n",
    "\n",
    "\n",
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    aggregated_df[\"error_category\"] = aggregated_df.apply(\n",
    "        error_category, axis=1\n",
    "    )\n",
    "\n",
    "    error_category_summary = (\n",
    "        aggregated_df\n",
    "        .groupby([\"prompt_type\", \"error_category\"])\n",
    "        .size()\n",
    "        .reset_index(name=\"count\")\n",
    "    )\n",
    "\n",
    "    display(error_category_summary)\n",
    "\n",
    "    high_risk = aggregated_df[\n",
    "        (aggregated_df[\"ground_truth\"] == \"Misleading/False\") &\n",
    "        (aggregated_df[\"mode_prediction\"] == \"Reliable/Supported\")\n",
    "    ]\n",
    "\n",
    "    print(\"High-risk false-acceptance cases:\", len(high_risk))\n",
    "    display(high_risk.head(50))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b7f3687",
   "metadata": {},
   "source": [
    "## 35. Figure 4.9 — Error categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cfc9961",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    error_plot = (\n",
    "        aggregated_df[aggregated_df[\"error_category\"] != \"Correct\"]\n",
    "        .groupby([\"prompt_type\", \"error_category\"])\n",
    "        .size()\n",
    "        .unstack(fill_value=0)\n",
    "    )\n",
    "\n",
    "    if not error_plot.empty:\n",
    "        error_plot.plot(kind=\"bar\", figsize=(12,6))\n",
    "        plt.title(\"Figure 4.9: LLM Error Categories\")\n",
    "        plt.xlabel(\"Prompting condition\")\n",
    "        plt.ylabel(\"Number of errors\")\n",
    "        plt.xticks(rotation=0)\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "    else:\n",
    "        print(\"No errors recorded.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af8e7ff1",
   "metadata": {},
   "source": [
    "## 36. Export Chapter 4 files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b51f671",
   "metadata": {},
   "outputs": [],
   "source": [
    "if RUN_FULL_EXPERIMENT:\n",
    "\n",
    "    exports = {\n",
    "        \"PHEMEPlus_Master_Rumour_Dataset.csv\": master_df,\n",
    "        \"PHEMEPlus_Experiment_Sample.csv\": experiment_df,\n",
    "        \"PHEMEPlus_FewShot_Demonstrations.csv\": demo_df,\n",
    "        \"PHEMEPlus_LLM_Experiment_Results.csv\": results_df,\n",
    "        \"PHEMEPlus_LLM_Aggregated.csv\": aggregated_df,\n",
    "        \"PHEMEPlus_Metrics.csv\": metrics_df.reset_index(),\n",
    "        \"PHEMEPlus_Class_Metrics.csv\": class_metrics_df,\n",
    "        \"PHEMEPlus_Error_Rates.csv\": error_rates_df,\n",
    "        \"PHEMEPlus_Consistency.csv\": consistency_df,\n",
    "        \"PHEMEPlus_Consistency_Summary.csv\": consistency_summary.reset_index(),\n",
    "        \"PHEMEPlus_Unverified_Analysis.csv\": unverified_df.reset_index(),\n",
    "        \"PHEMEPlus_Prompt_Sensitivity.csv\": sensitivity_df,\n",
    "        \"PHEMEPlus_Error_Categories.csv\": error_category_summary\n",
    "    }\n",
    "\n",
    "    for filename, frame in exports.items():\n",
    "        frame.to_csv(\n",
    "            OUTPUT_DIR / filename,\n",
    "            index=False,\n",
    "            encoding=\"utf-8-sig\"\n",
    "        )\n",
    "\n",
    "    print(\"Exported to:\", OUTPUT_DIR)\n",
    "    for filename in exports:\n",
    "        print(\" -\", filename)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78702603",
   "metadata": {},
   "source": [
    "# 37. Chapter 4 reporting checklist\n",
    "\n",
    "Use the generated CSVs and figures to report:\n",
    "\n",
    "### 4.1 Dataset\n",
    "- event distribution\n",
    "- True / False / Unverified distribution\n",
    "- evidence availability\n",
    "- evaluation sample\n",
    "\n",
    "### 4.2 Generative AI setup\n",
    "- model: `openai/gpt-oss-120b`\n",
    "- Hugging Face Inference Providers\n",
    "- Zero-Shot\n",
    "- Definition-Based\n",
    "- Few-Shot\n",
    "- repeated runs\n",
    "- temperature\n",
    "- response time\n",
    "\n",
    "### 4.3 Performance\n",
    "- Accuracy\n",
    "- Macro-Precision\n",
    "- Macro-Recall\n",
    "- Macro-F1\n",
    "\n",
    "### 4.4 Reliability\n",
    "- repeated-run agreement\n",
    "- Cohen's kappa\n",
    "- prompt sensitivity\n",
    "\n",
    "### 4.5 Uncertainty and safety-relevant errors\n",
    "- Unverified recall\n",
    "- forced classification rate\n",
    "- false claims accepted as reliable\n",
    "\n",
    "**Do not invent numerical results. Report the values generated by the experiment.**\n",
    "\n",
    "**Security:** never include `HF_TOKEN` in the dissertation, screenshots or submitted notebook.\n"
   ]
  }
 ],
 "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}