Upload 2 files

app.py

@@ -0,0 +1,296 @@
+# app.py
+"""
+Email Deadline Summarizer (Gradio)
+----------------------------------
+Drag & drop a CSV of emails, paste your OpenAI API key, and get
+deadline-driven summaries + next steps.
+
+Expected CSV columns (case-insensitive, best-effort mapping):
+- subject
+- received / date / datetime / timestamp
+- from / sender / sender_name / sender_email
+- body / content / text / snippet
+
+Outputs:
+- A table with: Subject, Received, Sender Name, Summary, Next Step, Explicit Deadline
+- A downloadable CSV of the results
+
+Run:
+    pip install -r requirements.txt
+    python app.py
+"""
+
+import io
+import os
+import json
+import time
+import traceback
+from typing import List, Dict, Any, Optional, Tuple
+
+import gradio as gr
+import pandas as pd
+
+# OpenAI SDK v1.x
+try:
+    from openai import OpenAI
+except Exception:
+    OpenAI = None
+
+
+# -----------------------------
+# Utilities
+# -----------------------------
+CANDIDATE_DATE_COLS = ["received", "date", "datetime", "timestamp"]
+CANDIDATE_FROM_COLS = ["from", "sender", "sender_name", "sender_email"]
+CANDIDATE_SUBJECT_COLS = ["subject", "title"]
+CANDIDATE_BODY_COLS = ["body", "content", "text", "snippet"]
+
+DEFAULT_MODEL = "gpt-4o-mini"  # adjust as desired
+
+
+def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """Map common column variations to a standard schema, if possible."""
+    lower_cols = {c.lower().strip(): c for c in df.columns}
+    def pick(candidates: List[str]) -> Optional[str]:
+        for c in candidates:
+            if c in lower_cols:
+                return lower_cols[c]
+        return None
+
+    col_subject = pick(CANDIDATE_SUBJECT_COLS)
+    col_date = pick(CANDIDATE_DATE_COLS)
+    col_from = pick(CANDIDATE_FROM_COLS)
+    col_body = pick(CANDIDATE_BODY_COLS)
+
+    # Create a new standardized dataframe with only the columns we need (if available)
+    std = pd.DataFrame()
+    if col_subject and col_subject in df:
+        std["subject"] = df[col_subject].astype(str)
+    else:
+        std["subject"] = ""
+
+    if col_date and col_date in df:
+        std["received"] = df[col_date].astype(str)
+    else:
+        std["received"] = ""
+
+    if col_from and col_from in df:
+        std["sender_name"] = df[col_from].astype(str)
+    else:
+        std["sender_name"] = ""
+
+    if col_body and col_body in df:
+        std["body"] = df[col_body].astype(str)
+    else:
+        # If no body-like column found, try to assemble from other fields
+        std["body"] = (
+            df.apply(lambda r: " ".join([str(x) for x in r.values if pd.notna(x)]), axis=1)
+            if not df.empty else ""
+        ).astype(str)
+
+    return std
+
+
+def _build_prompt() -> str:
+    """The instruction we send for each email."""
+    return (
+        "You are an executive assistant that triages emails for deadlines.\n"
+        "For the given email (subject, received time, sender, and body), produce a JSON object with:\n"
+        "- Subject: the email's subject line\n"
+        "- Received: the time/date received (restate clearly)\n"
+        "- Sender Name: the sender's name (or best guess from From field)\n"
+        "- Summary: a concise 2–3 sentence summary of the content\n"
+        "- Next Step: one concrete action item to meet the deadline\n"
+        "- Explicit Deadline: a specific date/time. If none is stated, infer the *earliest prudent* deadline (today if urgent) and clearly label as inferred.\n\n"
+        "Rules:\n"
+        "1) If no action or deadline is implied, mark Explicit Deadline as 'None' and Next Step as 'Monitor only'.\n"
+        "2) Keep JSON keys exactly as written above.\n"
+        "3) Return ONLY valid minified JSON (no backticks, no extra text)."
+    )
+
+
+def _call_openai(client: "OpenAI", model: str, email: Dict[str, str]) -> Dict[str, Any]:
+    """Call OpenAI to summarize a single email into deadline-driven JSON."""
+    system = _build_prompt()
+    user = json.dumps({
+        "Subject": email.get("subject", ""),
+        "Received": email.get("received", ""),
+        "Sender Name": email.get("sender_name", ""),
+        "Body": email.get("body", ""),
+    }, ensure_ascii=False)
+
+    resp = client.responses.create(
+        model=model,
+        input=[
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+        temperature=0.2,
+    )
+    # Extract text depending on SDK's shape; using .output_text for convenience
+    text = getattr(resp, "output_text", None)
+    if text is None:
+        # Fallback: attempt to navigate the structure
+        try:
+            text = resp.output[0].content[0].text
+        except Exception:
+            text = ""
+
+    # Parse JSON
+    try:
+        data = json.loads(text)
+        if not isinstance(data, dict):
+            raise ValueError("Model did not return a JSON object.")
+        return {
+            "Subject": data.get("Subject", email.get("subject", "")),
+            "Received": data.get("Received", email.get("received", "")),
+            "Sender Name": data.get("Sender Name", email.get("sender_name", "")),
+            "Summary": data.get("Summary", ""),
+            "Next Step": data.get("Next Step", ""),
+            "Explicit Deadline": data.get("Explicit Deadline", ""),
+        }
+    except Exception:
+        # Return a recoverable error row
+        return {
+            "Subject": email.get("subject", ""),
+            "Received": email.get("received", ""),
+            "Sender Name": email.get("sender_name", ""),
+            "Summary": f"ERROR parsing model output. Raw: {text[:400]}",
+            "Next Step": "—",
+            "Explicit Deadline": "—",
+        }
+
+
+def process_csv(
+    csv_file: Optional[io.BytesIO],
+    api_key: str,
+    model: str,
+    max_rows: int,
+    assume_utc_dates: bool,
+) -> Tuple[pd.DataFrame, str]:
+    """Main pipeline: read CSV, normalize, LLM summarize, return DF + CSV bytes path."""
+    if OpenAI is None:
+        raise RuntimeError("OpenAI SDK not installed. Please `pip install openai>=1.40`.")
+
+    if not api_key:
+        raise gr.Error("Please provide your OpenAI API key.")
+
+    if csv_file is None:
+        raise gr.Error("Please upload a CSV file.")
+
+    # Load CSV
+    try:
+        df = pd.read_csv(csv_file)
+    except Exception:
+        # Try with ISO-8859-1 fallback
+        csv_file.seek(0)
+        df = pd.read_csv(csv_file, encoding="latin-1")
+
+    if df.empty:
+        raise gr.Error("The uploaded CSV appears to be empty.")
+
+    # Normalize cols -> subject, received, sender_name, body
+    std = _normalize_columns(df)
+
+    # Trim to max_rows
+    if max_rows > 0:
+        std = std.head(max_rows)
+
+    # Date normalization (optional best-effort)
+    if assume_utc_dates and "received" in std.columns:
+        # Just a simple pass-through; user can format later
+        std["received"] = std["received"].astype(str)
+
+    client = OpenAI(api_key=api_key)
+
+    # Process rows
+    rows = []
+    for _, r in std.iterrows():
+        email = {
+            "subject": r.get("subject", ""),
+            "received": r.get("received", ""),
+            "sender_name": r.get("sender_name", ""),
+            "body": r.get("body", ""),
+        }
+        try:
+            out = _call_openai(client, model, email)
+        except Exception as e:
+            out = {
+                "Subject": email["subject"],
+                "Received": email["received"],
+                "Sender Name": email["sender_name"],
+                "Summary": f"ERROR calling model: {str(e)}",
+                "Next Step": "—",
+                "Explicit Deadline": "—",
+            }
+        rows.append(out)
+        # gentle pacing to avoid rate spikes
+        time.sleep(0.15)
+
+    result_df = pd.DataFrame(rows, columns=[
+        "Subject", "Received", "Sender Name", "Summary", "Next Step", "Explicit Deadline"
+    ])
+
+    # Save CSV to a temp in /mnt/data for download
+    out_path = "/mnt/data/deadline_email_summaries.csv"
+    result_df.to_csv(out_path, index=False)
+
+    return result_df, out_path
+
+
+# -----------------------------
+# Gradio UI
+# -----------------------------
+with gr.Blocks(title="Email Deadline Summarizer") as demo:
+    gr.Markdown(
+        "# Email Deadline Summarizer\n"
+        "Upload a CSV of emails, add your OpenAI API key, and get deadline-driven summaries + next steps.\n"
+        "- ⚠️ Costs: Each row triggers a model call. Use the row limit to control spend.\n"
+        "- 🔐 Your key is used only in this session."
+    )
+
+    with gr.Row():
+        csv_in = gr.File(label="Drag & drop your CSV", file_types=[".csv"])
+        api_key_in = gr.Textbox(
+            label="OpenAI API Key (starts with `sk-...`)",
+            type="password",
+            placeholder="Paste your key here"
+        )
+
+    with gr.Row():
+        model_in = gr.Dropdown(
+            label="Model",
+            choices=[
+                "gpt-4o", "gpt-4o-mini", "gpt-4.1", "gpt-4.1-mini",
+                "gpt-4o-mini-transcribe", "gpt-4o-realtime-preview"
+            ],
+            value=DEFAULT_MODEL
+        )
+        max_rows_in = gr.Slider(
+            label="Max rows to process (per run)",
+            minimum=1, maximum=500, value=25, step=1
+        )
+        assume_utc_in = gr.Checkbox(
+            label="Received timestamps are UTC strings (best-effort)",
+            value=True
+        )
+
+    run_btn = gr.Button("Summarize Emails")
+    out_df = gr.Dataframe(label="Deadline-Driven Summaries", interactive=False)
+    out_file = gr.File(label="Download results CSV")
+
+    def _run(csv_file, api_key, model, max_rows, assume_utc):
+        try:
+            return process_csv(csv_file, api_key, model, int(max_rows), bool(assume_utc))
+        except Exception as e:
+            tb = traceback.format_exc()
+            raise gr.Error(f"{e}\n\n{tb}")
+
+    run_btn.click(
+        fn=_run,
+        inputs=[csv_in, api_key_in, model_in, max_rows_in, assume_utc_in],
+        outputs=[out_df, out_file]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.44.0
+pandas>=2.1.4
+openai>=1.40.0