Add new charting functions and enhance tools for serious outcomes and time-series analysis

app.py

@@ -1,6 +1,17 @@
 import gradio as gr
-from openfda_client import get_top_adverse_events, get_drug_event_pair_frequency
-from plotting import create_bar_chart
+from openfda_client import (
+    get_top_adverse_events, 
+    get_drug_event_pair_frequency, 
+    get_serious_outcomes,
+    get_time_series_data,
+    get_report_source_data
+)
+from plotting import (
+    create_bar_chart, 
+    create_outcome_chart,
+    create_time_series_chart,
+    create_pie_chart
+)
 import pandas as pd
 
 # --- Formatting Functions ---
@@ -26,6 +37,27 @@ def format_top_events_results(data: dict, drug_name: str) -> str:
     except Exception as e:
         return f"An error occurred while formatting the data: {e}"
 
+def format_serious_outcomes_results(data: dict, drug_name: str) -> str:
+    """Formats the results for the serious outcomes tool."""
+    if "error" in data:
+        return f"An error occurred: {data['error']}"
+    
+    if "results" not in data or not data["results"]:
+        return f"No serious outcome data found for '{drug_name}'. The drug may not be in the database or it might be misspelled."
+
+    header = f"Top Serious Outcomes for '{drug_name.title()}'\n"
+    header += "Source: FDA FAERS via OpenFDA\n"
+    header += "Disclaimer: Spontaneous reports do not prove causation. Consult a healthcare professional.\n"
+    header += "---------------------------------------------------\n"
+
+    try:
+        df = pd.DataFrame(data["results"])
+        df = df.rename(columns={"term": "Serious Outcome", "count": "Report Count"})
+        result_string = df.to_string(index=False)
+        return header + result_string
+    except Exception as e:
+        return f"An error occurred while formatting the data: {e}"
+
 def format_pair_frequency_results(data: dict, drug_name: str, event_name: str) -> str:
     """Formats the results for the drug-event pair frequency tool."""
     if "error" in data:
@@ -43,21 +75,49 @@ def format_pair_frequency_results(data: dict, drug_name: str, event_name: str) -
 
 # --- Tool Functions ---
 
-def top_adverse_events_tool(drug_name: str):
+def top_adverse_events_tool(drug_name: str, patient_sex: str = "all", min_age: int = 0, max_age: int = 120):
     """
     MCP Tool: Finds the top reported adverse events for a given drug.
 
     Args:
         drug_name (str): The name of the drug to search for.
+        patient_sex (str): The patient's sex to filter by.
+        min_age (int): The minimum age for the filter.
+        max_age (int): The maximum age for the filter.
     
     Returns:
         tuple: A Plotly figure and a formatted string with the top adverse events.
     """
-    data = get_top_adverse_events(drug_name)
+    sex_code = None
+    if patient_sex == "Male":
+        sex_code = "1"
+    elif patient_sex == "Female":
+        sex_code = "2"
+    
+    age_range = None
+    if min_age > 0 or max_age < 120:
+        age_range = (min_age, max_age)
+
+    data = get_top_adverse_events(drug_name, patient_sex=sex_code, age_range=age_range)
     chart = create_bar_chart(data, drug_name)
     text_summary = format_top_events_results(data, drug_name)
     return chart, text_summary
 
+def serious_outcomes_tool(drug_name: str):
+    """
+    MCP Tool: Finds the top reported serious outcomes for a given drug.
+
+    Args:
+        drug_name (str): The name of the drug to search for.
+    
+    Returns:
+        tuple: A Plotly figure and a formatted string with the top serious outcomes.
+    """
+    data = get_serious_outcomes(drug_name)
+    chart = create_outcome_chart(data, drug_name)
+    text_summary = format_serious_outcomes_results(data, drug_name)
+    return chart, text_summary
+
 def drug_event_stats_tool(drug_name: str, event_name: str):
     """
     MCP Tool: Gets the total number of reports for a specific drug and adverse event pair.
@@ -72,6 +132,37 @@ def drug_event_stats_tool(drug_name: str, event_name: str):
     data = get_drug_event_pair_frequency(drug_name, event_name)
     return format_pair_frequency_results(data, drug_name, event_name)
 
+def time_series_tool(drug_name: str, event_name: str, aggregation: str):
+    """
+    MCP Tool: Creates a time-series plot for a drug-event pair.
+
+    Args:
+        drug_name (str): The name of the drug.
+        event_name (str): The name of the adverse event.
+        aggregation (str): Time aggregation ('Yearly' or 'Quarterly').
+
+    Returns:
+        A Plotly figure.
+    """
+    agg_code = 'Y' if aggregation == 'Yearly' else 'Q'
+    data = get_time_series_data(drug_name, event_name)
+    chart = create_time_series_chart(data, drug_name, event_name, time_aggregation=agg_code)
+    return chart
+
+def report_source_tool(drug_name: str):
+    """
+    MCP Tool: Creates a pie chart of report sources for a given drug.
+
+    Args:
+        drug_name (str): The name of the drug.
+
+    Returns:
+        A Plotly figure.
+    """
+    data = get_report_source_data(drug_name)
+    chart = create_pie_chart(data, drug_name)
+    return chart
+
 # --- Gradio Interface ---
 
 interface1 = gr.Interface(
@@ -80,7 +171,24 @@ interface1 = gr.Interface(
         gr.Textbox(
             label="Drug Name", 
             info="Enter a brand or generic drug name (e.g., 'Aspirin', 'Lisinopril')."
-        )
+        ),
+        gr.Radio(
+            ["All", "Male", "Female"], 
+            label="Patient Sex", 
+            value="All"
+        ),
+        gr.Slider(
+            0, 120, 
+            value=0, 
+            label="Minimum Age", 
+            step=1
+        ),
+        gr.Slider(
+            0, 120, 
+            value=120, 
+            label="Maximum Age", 
+            step=1
+        ),
     ],
     outputs=[
         gr.Plot(label="Top Adverse Events Chart"),
@@ -91,6 +199,23 @@ interface1 = gr.Interface(
     examples=[["Lisinopril"], ["Ozempic"], ["Metformin"]],
 )
 
+interface3 = gr.Interface(
+    fn=serious_outcomes_tool,
+    inputs=[
+        gr.Textbox(
+            label="Drug Name", 
+            info="Enter a brand or generic drug name (e.g., 'Aspirin', 'Lisinopril')."
+        )
+    ],
+    outputs=[
+        gr.Plot(label="Top Serious Outcomes Chart"),
+        gr.Textbox(label="Top Serious Outcomes (Raw Data)", lines=15)
+    ],
+    title="Serious Outcome Analysis",
+    description="Find the most frequently reported serious outcomes (e.g., hospitalization, death) for a specific medication.",
+    examples=[["Lisinopril"], ["Ozempic"], ["Metformin"]],
+)
+
 interface2 = gr.Interface(
     fn=drug_event_stats_tool,
     inputs=[
@@ -103,9 +228,33 @@ interface2 = gr.Interface(
     examples=[["Lisinopril", "Cough"], ["Ozempic", "Nausea"]],
 )
 
+interface4 = gr.Interface(
+    fn=time_series_tool,
+    inputs=[
+        gr.Textbox(label="Drug Name", info="e.g., 'Ibuprofen'"),
+        gr.Textbox(label="Adverse Event", info="e.g., 'Headache'"),
+        gr.Radio(["Yearly", "Quarterly"], label="Aggregation", value="Yearly")
+    ],
+    outputs=[gr.Plot(label="Report Trends")],
+    title="Time-Series Trend Plotting",
+    description="Plot the number of adverse event reports over time for a specific drug-event pair.",
+    examples=[["Lisinopril", "Cough", "Yearly"], ["Ozempic", "Nausea", "Quarterly"]],
+)
+
+interface5 = gr.Interface(
+    fn=report_source_tool,
+    inputs=[
+        gr.Textbox(label="Drug Name", info="e.g., 'Aspirin', 'Lisinopril'")
+    ],
+    outputs=[gr.Plot(label="Report Source Breakdown")],
+    title="Report Source Breakdown",
+    description="Show a pie chart breaking down the source of the reports (e.g., Consumer, Physician).",
+    examples=[["Lisinopril"], ["Ozempic"]],
+)
+
 demo = gr.TabbedInterface(
-    [interface1, interface2], 
-    ["Top Events", "Event Frequency"],
+    [interface1, interface3, interface2, interface4, interface5], 
+    ["Top Events", "Serious Outcomes", "Event Frequency", "Time-Series Trends", "Report Sources"],
     title="Medication Adverse-Event Explorer"
 )
 

openfda_client.py

@@ -1,6 +1,7 @@
 import requests
 from cachetools import TTLCache, cached
 import time
+from typing import Optional, Tuple
 
 API_BASE_URL = "https://api.fda.gov/drug/event.json"
 # Cache with a TTL of 10 minutes (600 seconds)
@@ -9,13 +10,122 @@ cache = TTLCache(maxsize=256, ttl=600)
 # 240 requests per minute per IP. A 0.25s delay is a simple way to stay under.
 REQUEST_DELAY_SECONDS = 0.25
 
-def get_top_adverse_events(drug_name: str, limit: int = 10) -> dict:
+DRUG_SYNONYM_MAPPING = {
+    "tylenol": "acetaminophen",
+    "advil": "ibuprofen",
+    "motrin": "ibuprofen",
+    "aleve": "naproxen",
+    "benadryl": "diphenhydramine",
+    "claritin": "loratadine",
+    "zyrtec": "cetirizine",
+    "allegra": "fexofenadine",
+    "zantac": "ranitidine",
+    "pepcid": "famotidine",
+    "prilosec": "omeprazole",
+    "lipitor": "atorvastatin",
+    "zocor": "simvastatin",
+    "norvasc": "amlodipine",
+    "hydrochlorothiazide": "hctz",
+    "glucophage": "metformin",
+    "synthroid": "levothyroxine",
+    "ambien": "zolpidem",
+    "xanax": "alprazolam",
+    "prozac": "fluoxetine",
+    "zoloft": "sertraline",
+    "paxil": "paroxetine",
+    "lexapro": "escitalopram",
+    "cymbalta": "duloxetine",
+    "wellbutrin": "bupropion",
+    "desyrel": "trazodone",
+    "eliquis": "apixaban",
+    "xarelto": "rivaroxaban",
+    "pradaxa": "dabigatran",
+    "coumadin": "warfarin",
+    "januvia": "sitagliptin",
+    "tradjenta": "linagliptin",
+    "jardiance": "empagliflozin",
+    "farxiga": "dapagliflozin",
+    "invokana": "canagliflozin",
+    "ozempic": "semaglutide",
+    "victoza": "liraglutide",
+    "trulicity": "dulaglutide",
+    "humira": "adalimumab",
+    "enbrel": "etanercept",
+    "remicade": "infliximab",
+    "stelara": "ustekinumab",
+    "keytruda": "pembrolizumab",
+    "opdivo": "nivolumab",
+    "revlimid": "lenalidomide",
+    "rituxan": "rituximab",
+    "herceptin": "trastuzumab",
+    "avastin": "bevacizumab",
+    "spiriva": "tiotropium",
+    "advair": "fluticasone/salmeterol",
+    "symbicort": "budesonide/formoterol",
+    "singulair": "montelukast",
+    "lyrica": "pregabalin",
+    "neurontin": "gabapentin",
+    "topamax": "topiramate",
+    "lamictal": "lamotrigine",
+    "keppra": "levetiracetam",
+    "dilantin": "phenytoin",
+    "tegretol": "carbamazepine",
+    "depakote": "divalproex",
+    "vyvanse": "lisdexamfetamine",
+    "adderall": "amphetamine/dextroamphetamine",
+    "ritalin": "methylphenidate",
+    "concerta": "methylphenidate",
+    "focalin": "dexmethylphenidate",
+    "strattera": "atomoxetine",
+    "viagra": "sildenafil",
+    "cialis": "tadalafil",
+    "levitra": "vardenafil",
+    "bactrim": "sulfamethoxazole/trimethoprim",
+    "keflex": "cephalexin",
+    "augmentin": "amoxicillin/clavulanate",
+    "zithromax": "azithromycin",
+    "levaquin": "levofloxacin",
+    "cipro": "ciprofloxacin",
+    "diflucan": "fluconazole",
+    "tamiflu": "oseltamivir",
+    "valtrex": "valacyclovir",
+    "zofran": "ondansetron",
+    "phenergan": "promethazine",
+    "imitrex": "sumatriptan",
+    "flexeril": "cyclobenzaprine",
+    "soma": "carisoprodol",
+    "valium": "diazepam",
+    "ativan": "lorazepam",
+    "klonopin": "clonazepam",
+    "restoril": "temazepam",
+    "ultram": "tramadol",
+    "percocet": "oxycodone/acetaminophen",
+    "vicodin": "hydrocodone/acetaminophen",
+    "oxycontin": "oxycodone",
+    "dilaudid": "hydromorphone",
+    "morphine": "ms contin",
+    "fentanyl": "duragesic"
+}
+
+OUTCOME_MAPPING = {
+    "1": "Life-Threatening",
+    "2": "Hospitalization - Initial or Prolonged",
+    "3": "Disability",
+    "4": "Congenital Anomaly",
+    "5": "Required Intervention to Prevent Permanent Impairment/Damage",
+    "6": "Death",
+    "7": "Other Serious (Important Medical Event)",
+}
+
+def get_top_adverse_events(drug_name: str, limit: int = 10, patient_sex: Optional[str] = None, age_range: Optional[Tuple[int, int]] = None) -> dict:
     """
     Query OpenFDA to get the top adverse events for a given drug.
 
     Args:
         drug_name (str): The name of the drug to search for (brand or generic).
         limit (int): The maximum number of adverse events to return.
+        patient_sex (str): The patient's sex to filter by ('1' for Male, '2' for Female).
+        age_range (tuple): A tuple containing min and max age, e.g., (20, 50).
 
     Returns:
         dict: The JSON response from the API, or an error dictionary.
@@ -24,15 +134,26 @@ def get_top_adverse_events(drug_name: str, limit: int = 10) -> dict:
         return {"error": "Drug name cannot be empty."}
 
     drug_name_processed = drug_name.lower().strip()
+    drug_name_processed = DRUG_SYNONYM_MAPPING.get(drug_name_processed, drug_name_processed)
+
+    # Build the search query
+    search_terms = [f'patient.drug.medicinalproduct:"{drug_name_processed}"']
+    if patient_sex and patient_sex in ["1", "2"]:
+        search_terms.append(f'patient.patientsex:"{patient_sex}"')
+    if age_range and len(age_range) == 2:
+        min_age, max_age = age_range
+        search_terms.append(f'patient.patientonsetage:[{min_age} TO {max_age}]')
+
+    search_query = "+AND+".join(search_terms)
 
-    # Using a simple cache key
-    cache_key = f"top_events_{drug_name_processed}_{limit}"
+    # Using a simple cache key that includes filters
+    cache_key = f"top_events_{drug_name_processed}_{limit}_{patient_sex}_{age_range}"
 
     if cache_key in cache:
         return cache[cache_key]
 
     query = (
-        f'search=patient.drug.medicinalproduct:"{drug_name_processed}"'
+        f'search={search_query}'
         f'&count=patient.reaction.reactionmeddrapt.exact&limit={limit}'
     )
     
@@ -72,6 +193,7 @@ def get_drug_event_pair_frequency(drug_name: str, event_name: str) -> dict:
         return {"error": "Drug name and event name cannot be empty."}
 
     drug_name_processed = drug_name.lower().strip()
+    drug_name_processed = DRUG_SYNONYM_MAPPING.get(drug_name_processed, drug_name_processed)
     event_name_processed = event_name.lower().strip()
 
     cache_key = f"pair_freq_{drug_name_processed}_{event_name_processed}"
@@ -100,4 +222,160 @@ def get_drug_event_pair_frequency(drug_name: str, event_name: str) -> dict:
     except requests.exceptions.RequestException as req_err:
         return {"error": f"A network request error occurred: {req_err}"}
     except Exception as e:
-        return {"error": f"An unexpected error occurred: {e}"} 
+        return {"error": f"An unexpected error occurred: {e}"}
+
+def get_serious_outcomes(drug_name: str, limit: int = 10) -> dict:
+    """
+    Query OpenFDA to get the most frequent serious outcomes for a given drug.
+    Outcomes include: death, disability, hospitalization, etc.
+
+    Args:
+        drug_name (str): The name of the drug to search for.
+        limit (int): The maximum number of outcomes to return.
+
+    Returns:
+        dict: The JSON response from the API, or an error dictionary.
+    """
+    if not drug_name:
+        return {"error": "Drug name cannot be empty."}
+
+    drug_name_processed = drug_name.lower().strip()
+    drug_name_processed = DRUG_SYNONYM_MAPPING.get(drug_name_processed, drug_name_processed)
+    cache_key = f"serious_outcomes_{drug_name_processed}_{limit}"
+
+    if cache_key in cache:
+        return cache[cache_key]
+
+    query = (
+        f'search=patient.drug.medicinalproduct:"{drug_name_processed}"'
+        f'&count=patient.reaction.reactionoutcome.exact&limit={limit}'
+    )
+
+    try:
+        time.sleep(REQUEST_DELAY_SECONDS)
+        
+        response = requests.get(f"{API_BASE_URL}?{query}")
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        # Map outcome codes to human-readable names
+        if "results" in data:
+            for item in data["results"]:
+                item["term"] = OUTCOME_MAPPING.get(item["term"], f"Unknown ({item['term']})")
+        
+        cache[cache_key] = data
+        return data
+
+    except requests.exceptions.HTTPError as http_err:
+        if response.status_code == 404:
+            return {"error": f"No data found for drug: '{drug_name}'. It might be misspelled or not in the database."}
+        return {"error": f"HTTP error occurred: {http_err}"}
+    except requests.exceptions.RequestException as req_err:
+        return {"error": f"A network request error occurred: {req_err}"}
+    except Exception as e:
+        return {"error": f"An unexpected error occurred: {e}"}
+
+def get_time_series_data(drug_name: str, event_name: str) -> dict:
+    """
+    Query OpenFDA to get the time series data for a drug-event pair.
+
+    Args:
+        drug_name (str): The name of the drug.
+        event_name (str): The name of the adverse event.
+
+    Returns:
+        dict: The JSON response from the API, or an error dictionary.
+    """
+    if not drug_name or not event_name:
+        return {"error": "Drug name and event name cannot be empty."}
+
+    drug_name_processed = drug_name.lower().strip()
+    drug_name_processed = DRUG_SYNONYM_MAPPING.get(drug_name_processed, drug_name_processed)
+    event_name_processed = event_name.lower().strip()
+
+    cache_key = f"time_series_{drug_name_processed}_{event_name_processed}"
+    if cache_key in cache:
+        return cache[cache_key]
+
+    query = (
+        f'search=patient.drug.medicinalproduct:"{drug_name_processed}"'
+        f'+AND+patient.reaction.reactionmeddrapt:"{event_name_processed}"'
+        f'&count=receivedate'
+    )
+
+    try:
+        time.sleep(REQUEST_DELAY_SECONDS)
+        
+        response = requests.get(f"{API_BASE_URL}?{query}")
+        response.raise_for_status()
+        
+        data = response.json()
+        cache[cache_key] = data
+        return data
+
+    except requests.exceptions.HTTPError as http_err:
+        if response.status_code == 404:
+            return {"error": f"No data found for drug '{drug_name}' and event '{event_name}'. They may be misspelled or not in the database."}
+        return {"error": f"HTTP error occurred: {http_err}"}
+    except requests.exceptions.RequestException as req_err:
+        return {"error": f"A network request error occurred: {req_err}"}
+    except Exception as e:
+        return {"error": f"An unexpected error occurred: {e}"}
+
+def get_report_source_data(drug_name: str) -> dict:
+    """
+    Query OpenFDA to get the breakdown of report sources for a given drug.
+
+    Args:
+        drug_name (str): The name of the drug to search for.
+
+    Returns:
+        dict: The JSON response from the API, or an error dictionary.
+    """
+    if not drug_name:
+        return {"error": "Drug name cannot be empty."}
+
+    drug_name_processed = drug_name.lower().strip()
+    drug_name_processed = DRUG_SYNONYM_MAPPING.get(drug_name_processed, drug_name_processed)
+
+    cache_key = f"report_source_{drug_name_processed}"
+    if cache_key in cache:
+        return cache[cache_key]
+
+    query = (
+        f'search=patient.drug.medicinalproduct:"{drug_name_processed}"'
+        f'&count=primarysource.qualification.exact'
+    )
+
+    try:
+        time.sleep(REQUEST_DELAY_SECONDS)
+        
+        response = requests.get(f"{API_BASE_URL}?{query}")
+        response.raise_for_status()
+        
+        data = response.json()
+
+        if "results" in data:
+            for item in data["results"]:
+                item["term"] = QUALIFICATION_MAPPING.get(item["term"], f"Unknown ({item['term']})")
+
+        cache[cache_key] = data
+        return data
+
+    except requests.exceptions.HTTPError as http_err:
+        if response.status_code == 404:
+            return {"error": f"No data found for drug: '{drug_name}'."}
+        return {"error": f"HTTP error occurred: {http_err}"}
+    except requests.exceptions.RequestException as req_err:
+        return {"error": f"A network request error occurred: {req_err}"}
+    except Exception as e:
+        return {"error": f"An unexpected error occurred: {e}"}
+
+QUALIFICATION_MAPPING = {
+    "1": "Physician",
+    "2": "Pharmacist",
+    "3": "Other Health Professional",
+    "4": "Lawyer",
+    "5": "Consumer or non-health professional",
+} 

plotting.py

@@ -44,4 +44,129 @@ def create_bar_chart(data: dict, drug_name: str):
 
         return fig
     except Exception:
+        return None
+
+def create_outcome_chart(data: dict, drug_name: str):
+    """
+    Creates a Plotly bar chart for serious outcomes from OpenFDA data.
+
+    Args:
+        data (dict): The data from the OpenFDA client.
+        drug_name (str): The name of the drug.
+
+    Returns:
+        A Plotly Figure object if data is valid, otherwise None.
+    """
+    if "error" in data or "results" not in data or not data["results"]:
+        return None
+
+    try:
+        df = pd.DataFrame(data["results"])
+        df = df.rename(columns={"term": "Serious Outcome", "count": "Report Count"})
+        
+        df['Report Count'] = pd.to_numeric(df['Report Count'])
+        df = df.sort_values(by="Report Count", ascending=True)
+
+        fig = go.Figure(
+            go.Bar(
+                x=df["Report Count"],
+                y=df["Serious Outcome"],
+                orientation='h',
+                marker=dict(color='crimson') # Different color for distinction
+            )
+        )
+
+        fig.update_layout(
+            title_text=f"Top Serious Outcomes for {drug_name.title()}",
+            xaxis_title="Number of Reports",
+            yaxis_title="Serious Outcome",
+            yaxis=dict(automargin=True),
+            height=max(400, len(df) * 40)
+        )
+
+        return fig
+    except Exception:
+        return None
+
+def create_time_series_chart(data: dict, drug_name: str, event_name: str, time_aggregation: str = 'Y'):
+    """
+    Creates a Plotly time-series chart from OpenFDA data.
+
+    Args:
+        data (dict): The data from the OpenFDA client.
+        drug_name (str): The name of the drug.
+        event_name (str): The name of the adverse event.
+        time_aggregation (str): The time unit for aggregation ('Y' for year, 'Q' for quarter).
+
+    Returns:
+        A Plotly Figure object if data is valid, otherwise None.
+    """
+    if "error" in data or "results" not in data or not data["results"]:
+        return None
+
+    try:
+        df = pd.DataFrame(data["results"])
+        df['time'] = pd.to_datetime(df['time'], format='%Y%m%d')
+        
+        # Resample data
+        df = df.set_index('time').resample(time_aggregation)['count'].sum().reset_index()
+        
+        aggregation_label = "Year" if time_aggregation == 'Y' else "Quarter"
+
+        fig = go.Figure(
+            go.Scatter(
+                x=df["time"],
+                y=df["count"],
+                mode='lines+markers',
+                line=dict(color='royalblue'),
+            )
+        )
+
+        fig.update_layout(
+            title_text=f"Report Trend for {drug_name.title()} and {event_name.title()}",
+            xaxis_title=f"Report {aggregation_label}",
+            yaxis_title="Number of Reports",
+            yaxis=dict(automargin=True),
+        )
+
+        return fig
+    except Exception as e:
+        print(f"Error creating time-series chart: {e}")
+        return None
+
+def create_pie_chart(data: dict, drug_name: str):
+    """
+    Creates a Plotly pie chart for report source breakdown.
+
+    Args:
+        data (dict): The data from the OpenFDA client.
+        drug_name (str): The name of the drug.
+
+    Returns:
+        A Plotly Figure object if data is valid, otherwise None.
+    """
+    if "error" in data or "results" not in data or not data["results"]:
+        return None
+
+    try:
+        df = pd.DataFrame(data["results"])
+        df = df.rename(columns={"term": "Source", "count": "Count"})
+
+        fig = go.Figure(
+            go.Pie(
+                labels=df["Source"],
+                values=df["Count"],
+                hole=.3,
+                pull=[0.05] * len(df) # Explode slices slightly
+            )
+        )
+
+        fig.update_layout(
+            title_text=f"Report Sources for {drug_name.title()}",
+            showlegend=True
+        )
+
+        return fig
+    except Exception as e:
+        print(f"Error creating pie chart: {e}")
         return None