Update app.py

app.py

@@ -1,7 +1,5 @@
 ###############################################################################
 #  Sozo Business Studio · AI transforms business data into compelling narratives
-#  FULL, DROP-IN SCRIPT  –  capped at 5 charts & 5 slides, Arrow-safe previews,
-#  DeepGram TTS, robust chart tags, fixed slide navigation / progress
 ###############################################################################
 import os, re, json, hashlib, uuid, base64, io, tempfile, wave, requests
 from pathlib import Path
@@ -20,434 +18,325 @@ from pptx.util import Inches, Pt
 from langchain_experimental.agents import create_pandas_dataframe_agent
 from langchain_google_genai import ChatGoogleGenerativeAI
 from google import genai
-from google.genai import types
 
 # ─────────────────────────────────────────────────────────────────────────────
-# PAGE CONFIG
-# ─────────────────────────────────────────────────────────────────────────────
-st.set_page_config(page_title="Sozo Business Studio", layout="wide")
-st.title("📊 Sozo Business Studio")
-st.caption("AI transforms business data into compelling narratives.")
-
-# ─────────────────────────────────────────────────────────────────────────────
-# CONSTANTS & FONT SETUP
+# CONSTANTS & API KEYS
 # ─────────────────────────────────────────────────────────────────────────────
 FONT_DIR = Path(__file__).parent if "__file__" in globals() else Path(".")
 FONT_REG = FONT_DIR / "NotoSans-Regular.ttf"
 FONT_BLD = FONT_DIR / "NotoSans-Bold.ttf"
 FONT_FAM = "NotoSans"
 
-SLIDES      = 5     # 🔒 maximum number of slides
-MAX_CHARTS  = 5     # 🔒 maximum number of charts
+SLIDES      = 5          # hard cap
+MAX_CHARTS  = 5          # hard cap
 
-API_KEY = os.getenv("GEMINI_API_KEY")          # Gemini (LLM)
+API_KEY = os.getenv("GEMINI_API_KEY")
 if not API_KEY:
-    st.error("⚠️ GEMINI_API_KEY environment variable is not set."); st.stop()
-try:
-    GEM = genai.Client(api_key=API_KEY)
-except Exception as e:
-    st.error(f"❌ Failed to initialise Google GenAI Client: {e}"); st.stop()
+    st.error("Set GEMINI_API_KEY"); st.stop()
+GEM = genai.Client(api_key=API_KEY)
 
-DG_KEY = os.getenv("DEEPGRAM_API_KEY")         # DeepGram (TTS)
+DG_KEY = os.getenv("DEEPGRAM_API_KEY")   # optional narration
 
 # ─────────────────────────────────────────────────────────────────────────────
-# SESSION STATE INITIALISATION
+# STATE
 # ─────────────────────────────────────────────────────────────────────────────
-for k, v in {"bundles": {}, "slide_idx": 0,
-             "active_bundle_key": None, "upload_errors": []}.items():
-    st.session_state.setdefault(k, v)
+st.set_page_config(page_title="Sozo Business Studio", layout="wide")
+st.title("📊 Sozo Business Studio")
+st.caption("AI transforms business data into compelling narratives.")
+
+for k,v in {"bundles":{}, "slide_idx":0,
+            "active_bundle_key":None}.items():
+    st.session_state.setdefault(k,v)
 
 # ─────────────────────────────────────────────────────────────────────────────
 # HELPERS
 # ─────────────────────────────────────────────────────────────────────────────
 sha1_bytes = lambda b: hashlib.sha1(b).hexdigest()
 
-def validate_file_upload(uploaded_file):
-    errs = []
-    if uploaded_file is None:
-        errs.append("No file uploaded"); return errs
-    if uploaded_file.size > 50 * 1024 * 1024:
-        errs.append("File size exceeds 50 MB limit")
-    if Path(uploaded_file.name).suffix.lower() not in (".csv", ".xlsx", ".xls"):
-        errs.append("Unsupported file type – upload CSV or Excel")
-    if uploaded_file.size == 0:
-        errs.append("File is empty")
-    return errs
-
-def load_dataframe_safely(file_bytes: bytes, filename: str):
+def validate_file_upload(f):
+    e=[]
+    if f is None: return ["No file uploaded"]
+    if f.size==0: e.append("File is empty")
+    if f.size>50*1024*1024: e.append("File >50 MB")
+    if Path(f.name).suffix.lower() not in (".csv",".xlsx",".xls"):
+        e.append("Unsupported type")
+    return e
+
+def load_dataframe_safely(bytes_, name):
     try:
-        ext = Path(filename).suffix.lower()
-        if ext == ".csv":
-            for enc in ("utf-8", "latin-1", "cp1252"):
-                try:
-                    df = pd.read_csv(io.BytesIO(file_bytes), encoding=enc); break
+        ext = Path(name).suffix.lower()
+        if ext==".csv":
+            for enc in ("utf-8","latin-1","cp1252"):
+                try: df=pd.read_csv(io.BytesIO(bytes_),encoding=enc); break
                 except UnicodeDecodeError: continue
             else:
-                df = pd.read_csv(io.BytesIO(file_bytes), encoding="utf-8", errors="replace")
-        elif ext in (".xlsx", ".xls"):
-            df = pd.read_excel(io.BytesIO(file_bytes))
+                df=pd.read_csv(io.BytesIO(bytes_),encoding="utf-8",errors="replace")
         else:
-            raise ValueError(f"Unsupported file format: {ext}")
-        if df.empty or len(df.columns) == 0:
-            raise ValueError("File contains no usable data")
-        df.columns = df.columns.astype(str).str.strip()
-        df = df.dropna(how="all")
-        if df.empty: raise ValueError("All rows are empty")
-        return df, None
+            df=pd.read_excel(io.BytesIO(bytes_))
+        if df.empty or len(df.columns)==0:
+            raise ValueError("No data")
+        df.columns=df.columns.astype(str).str.strip()
+        df=df.dropna(how="all")
+        if df.empty: raise ValueError("Rows all empty")
+        return df,None
     except Exception as exc:
-        return None, str(exc)
-
-def fix_bullet(text: str) -> str:
-    if not isinstance(text, str): return ""
-    repl = {"\x95":"•","\x96":"-","\x97":"—","\x91":"'","\x92":"'","\x93":'"',"\x94":'"'}
-    for b,g in repl.items(): text = text.replace(b,g)
-    return re.sub(r"[\x80-\x9f]", "", text)
-
-# ─── Arrow-compatibility helpers ────────────────────────────────────────────
-def make_arrow_compatible(df: pd.DataFrame) -> pd.DataFrame:
-    safe = df.copy()
-    for col in safe.columns:
-        dt = safe[col].dtype.name
-        if dt in ("Int64","Float64","Boolean"):
-            safe[col] = safe[col].astype(dt.lower(), copy=False)
-        if safe[col].apply(lambda x: isinstance(x, (np.dtype,))).any():
-            safe[col] = safe[col].astype(str)
+        return None,str(exc)
+
+def fix_bullet(txt):
+    if not isinstance(txt,str): return ""
+    repl = {"\x95":"•","\x96":"-","\x97":"—","\x91":"'",
+            "\x92":"'","\x93":'"',"\x94":'"'}
+    for b,g in repl.items(): txt=txt.replace(b,g)
+    return re.sub(r"[\x80-\x9f]","",txt)
+
+def arrow_df(df):
+    safe=df.copy()
+    for c in safe.columns:
+        if safe[c].dtype.name in ("Int64","Float64","Boolean"):
+            safe[c]=safe[c].astype(safe[c].dtype.name.lower())
+        if safe[c].apply(lambda x:isinstance(x,(np.dtype,))).any():
+            safe[c]=safe[c].astype(str)
     return safe
 
-def arrow_safe_info(df: pd.DataFrame) -> pd.DataFrame:
-    info = pd.DataFrame({
-        "Column": df.columns,
-        "Type": [str(t) for t in df.dtypes],
-        "Non-Null": df.notna().sum().values,
-        "Null": df.isna().sum().values,
-    })
-    return make_arrow_compatible(info)
-
-# ─── PCM→WAV helper ─────────────────────────────────────────────────────────
-def convert_pcm_to_wav(pcm, sr=24000, channels=1, width=2):
-    buf = io.BytesIO()
-    with wave.open(buf,'wb') as wf:
-        wf.setnchannels(channels); wf.setsampwidth(width); wf.setframerate(sr)
-        wf.writeframes(pcm)
-    buf.seek(0); return buf.getvalue()
-
-# ─── DeepGram TTS ───────────────────────────────────────────────────────────
+def arrow_info(df):
+    return arrow_df(pd.DataFrame({
+        "Column":df.columns,
+        "Type":[str(t) for t in df.dtypes],
+        "Non-Null":df.notna().sum(),
+        "Null":df.isna().sum()
+    }))
+
+def pcm_to_wav(pcm, sr=24000,ch=1,w=2):
+    b=io.BytesIO()
+    with wave.open(b,'wb') as wf:
+        wf.setnchannels(ch); wf.setsampwidth(w); wf.setframerate(sr); wf.writeframes(pcm)
+    b.seek(0); return b.getvalue()
+
 @st.cache_data(show_spinner=False)
-def generate_tts_audio(text: str):
-    if not DG_KEY: return None, None
-    text = re.sub(r"[^\w\s.,!?;:-]", "", text)[:500]
-    if not text: return None, None
+def deepgram_tts(text):
+    if not DG_KEY: return None,None
+    text=re.sub(r"[^\w\s.,!?;:-]","",text)[:500]
     try:
-        r = requests.post(
-            "https://api.deepgram.com/v1/speak",
+        r=requests.post("https://api.deepgram.com/v1/speak",
             params={"model":"aura-asteria-en"},
-            headers={"Authorization": f"Token {DG_KEY}",
+            headers={"Authorization":f"Token {DG_KEY}",
                      "Content-Type":"application/json"},
-            json={"text": text},
-            timeout=30,
-        )
+            json={"text":text},timeout=30)
         r.raise_for_status()
-        return r.content, r.headers.get("Content-Type","audio/mpeg")
-    except Exception:
-        return None, None
-
-# ─── Chart-tag regex (one source of truth) ──────────────────────────────────
-TAG_RE = re.compile(r"""
-    [<\[]\s*generate_?chart\s*[:=]?\s*["']?
-    (?P<desc>[^>\]'"’”]+?)["']?\s*[>\]]
-""", re.VERBOSE | re.IGNORECASE)
-
-extract_chart_tags = lambda txt: list(dict.fromkeys(
-    m.group("desc").strip() for m in TAG_RE.finditer(txt or "")
-))
-
-def replace_chart_tags(txt, chart_map, repl):
-    if not isinstance(txt, str): return ""
-    def _s(m):
-        d = m.group("desc").strip()
-        return repl(chart_map[d]) if d in chart_map else m.group(0)
-    return TAG_RE.sub(_s, txt)
-
-# ─── PDF & PPTX builders ────────────────────────────────────────────────────
-class PDF(FPDF, HTMLMixin): pass
-
-def build_pdf(md_src, chart_map):
-    try:
-        md_src = fix_bullet(md_src).replace("•","*")
-        md_src = replace_chart_tags(md_src, chart_map,
-                                    lambda p: f'<img src="{p}">')
-        html = MarkdownIt("commonmark", {"breaks":True}).enable("table").render(md_src)
-        pdf = PDF(); pdf.set_auto_page_break(True, margin=15)
-        added=False
-        for style,ttf in [("",FONT_REG),("B",FONT_BLD)]:
-            if ttf.exists():
-                try: pdf.add_font(FONT_FAM,style,str(ttf),uni=True); added=True
+        return r.content,r.headers.get("Content-Type","audio/mpeg")
+    except Exception: return None,None
+
+TAG_RE=re.compile(r'[<\[]\s*generate_?chart\s*[:=]?\s*["\']?(?P<d>[^>\]\'"”’]+?)["\']?\s*[>\]]',re.I)
+extract_chart_tags=lambda t:list(dict.fromkeys(m.group("d").strip() for m in TAG_RE.finditer(t or "")))
+def repl_tags(txt,map_,f):
+    def sub(m):
+        d=m.group("d").strip()
+        return f(map_[d]) if d in map_ else m.group(0)
+    return TAG_RE.sub(sub,txt)
+
+class PDF(FPDF,HTMLMixin): pass
+
+def build_pdf(md,charts):
+    md=fix_bullet(md).replace("•","*")
+    md=repl_tags(md,charts,lambda p:f'<img src="{p}">')
+    html=MarkdownIt("commonmark",{"breaks":True}).enable("table").render(md)
+    pdf=PDF(); pdf.set_auto_page_break(True,margin=15)
+    added=False
+    for s,t in [("",FONT_REG),("B",FONT_BLD)]:
+        if t.exists():
+            try: pdf.add_font(FONT_FAM,s,str(t),uni=True); added=True
+            except: pass
+    if added: pdf.set_fallback_fonts([FONT_FAM])
+    pdf.add_page(); pdf.set_font(FONT_FAM if added else "Arial","B",18)
+    pdf.cell(0,12,"AI-Generated Business Report",ln=True); pdf.ln(3)
+    pdf.set_font(FONT_FAM if added else "Arial","",11)
+    pdf.write_html(html)
+    return bytes(pdf.output(dest="S"))
+
+def build_pptx(slides,charts):
+    prs=Presentation(); layout=prs.slide_layouts[1]
+    for raw in slides:
+        rc=fix_bullet(raw); tags=extract_chart_tags(rc)
+        lines=[l.strip(" •-") for l in rc.splitlines() if l.strip()]
+        title=lines[0] if lines else "Slide"
+        bullets=[l for l in lines[1:] if not TAG_RE.search(l)]
+        s=prs.slides.add_slide(layout); s.shapes.title.text=title
+        tf=s.shapes.placeholders[1].text_frame; tf.clear(); tf.word_wrap=True
+        for b in bullets:
+            p=tf.add_paragraph(); p.text=b; p.font.size=Pt(20)
+        for t in tags:
+            if t in charts:
+                try: s.shapes.add_picture(charts[t],Inches(1),Inches(3.5),width=Inches(8))
                 except: pass
-        if added: pdf.set_fallback_fonts([FONT_FAM])
-        pdf.add_page()
-        pdf.set_font(FONT_FAM if added else "Arial","B",18)
-        pdf.cell(0,12,"AI-Generated Business Report",ln=True); pdf.ln(3)
-        pdf.set_font(FONT_FAM if added else "Arial","",11)
-        pdf.write_html(html)
-        return bytes(pdf.output(dest="S"))
-    except Exception as e:
-        st.error(f"PDF generation failed: {e}"); return b""
-
-def build_pptx(slides, chart_map):
-    try:
-        prs, layout = Presentation(), Presentation().slide_layouts[1]
-        for raw in slides:
-            rc = fix_bullet(raw)
-            tags = extract_chart_tags(rc)
-            lines = [ln.strip(" •-") for ln in rc.splitlines() if ln.strip()]
-            title = lines[0] if lines else "Slide"
-            bullets = [ln for ln in lines[1:] if not TAG_RE.search(ln)]
-            slide = prs.slides.add_slide(layout)
-            slide.shapes.title.text = title
-            tf = slide.shapes.placeholders[1].text_frame; tf.clear(); tf.word_wrap=True
-            for ln in bullets:
-                p = tf.add_paragraph(); p.text = ln; p.font.size = Pt(20)
-            for t in tags:
-                if t in chart_map:
-                    try:
-                        slide.shapes.add_picture(chart_map[t],
-                                                 Inches(1), Inches(3.5),
-                                                 width=Inches(8))
-                    except: pass
-                    break
-        bio = io.BytesIO(); prs.save(bio); return bio.getvalue()
-    except Exception as e:
-        st.error(f"PPTX generation failed: {e}"); return b""
-
-# ─── ASSET GENERATOR ────────────────────────────────────────────────────────
+                break
+    bio=io.BytesIO(); prs.save(bio); return bio.getvalue()
+
+# ─────────────────────────────────────────────────────────────────────────────
+# GENERATOR
+# ─────────────────────────────────────────────────────────────────────────────
 @st.cache_data(show_spinner=False)
-def generate_assets(_key, file_bytes, filename, mode, ctx):
-    df, err = load_dataframe_safely(file_bytes, filename)
+def make_assets(key,bytes_,name,mode,ctx):
+    df,err=load_dataframe_safely(bytes_,name)
     if err: st.error(err); return None
-    try:
-        llm = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash", google_api_key=API_KEY, temperature=0.1)
-    except Exception as e:
-        st.error(f"LLM init failed: {e}"); return None
-    data_ctx = {
-        "shape": df.shape,
-        "columns": list(df.columns),
-        "dtypes": df.dtypes.astype(str).to_dict(),
-        "sample": df.head(3).fillna("N/A").to_dict(),
-        "numeric_columns": df.select_dtypes("number").columns.tolist(),
-        "user_ctx": ctx or "General business analysis",
-    }
-    outputs = {}
+    llm=ChatGoogleGenerativeAI(model="gemini-2.5-flash",
+                               google_api_key=API_KEY,temperature=0.1)
+    ctx_data={
+        "shape":df.shape,
+        "columns":list(df.columns),
+        "dtypes":df.dtypes.astype(str).to_dict(),
+        "sample":df.head(3).fillna("N/A").to_dict(),
+        "numeric_columns":df.select_dtypes("number").columns.tolist(),
+        "user_ctx":ctx or "General business analysis"}
+    outputs={}
     if mode in ("Report","Both"):
-        try:
-            outputs["ReportAgent"] = llm.invoke(f"""
-You are a senior business analyst. Write an executive-level Markdown report
-with descriptive statistics, insights, and recommendations.
+        outputs["rep"]=llm.invoke(f"""
+Write an executive-level Markdown report with insights & recommendations.
+Use chart tags <generate_chart: "description"> where helpful.
 
-Data context: {json.dumps(data_ctx, indent=2)}
-
-Insert chart placeholders exactly like:
-<generate_chart: "description of chart">
+Data: {json.dumps(ctx_data,indent=2)}
 """).content
-        except Exception as e: st.error(f"Report gen failed: {e}")
     if mode in ("Presentation","Both"):
-        try:
-            outputs["PresentationAgent"] = llm.invoke(f"""
-Create exactly {SLIDES} concise slide scripts.
-
-Data context: {json.dumps(data_ctx, indent=2)}
-
+        outputs["pres"]=llm.invoke(f"""
+Create exactly {SLIDES} slides.
 Each slide:
 Slide X - Title
 • bullet 1 (≤15 words)
 • bullet 2
 <generate_chart: "description">
 """).content
-        except Exception as e: st.error(f"Presentation gen failed: {e}")
     if not outputs: return None
 
-    chart_descs = extract_chart_tags("\n".join(outputs.values()))[:MAX_CHARTS]
-    chart_paths = {}
+    chart_descs=extract_chart_tags("\n".join(outputs.values()))[:MAX_CHARTS]
+    chart_paths={}
     if chart_descs:
-        try:
-            agent = create_pandas_dataframe_agent(
-                llm=llm, df=df, verbose=False, allow_dangerous_code=True)
-            for d in chart_descs:
-                with plt.ioff():
-                    try:
-                        agent.run(f"Create a {d} with matplotlib and save.")
-                        fig = plt.gcf()
-                        if fig.axes:
-                            p = Path(tempfile.gettempdir())/f"{uuid.uuid4()}.png"
-                            fig.savefig(p, dpi=300, bbox_inches="tight",
-                                        facecolor="white")
-                            chart_paths[d]=str(p)
-                        plt.close("all")
-                    except: plt.close("all")
-        except Exception as e: st.warning(f"Chart agent failed: {e}")
-
-    pdf = pptx = preview = None; slides=[]
-    try:
-        if "ReportAgent" in outputs:
-            md = fix_bullet(outputs["ReportAgent"])
-            pdf = build_pdf(md, chart_paths)
-            preview = replace_chart_tags(
-                md, chart_paths,
-                lambda p: f'<img src="data:image/png;base64,{base64.b64encode(Path(p).read_bytes()).decode()}" style="max-width:100%;">')
-        if "PresentationAgent" in outputs:
-            rs = fix_bullet(outputs["PresentationAgent"])
-            parts = re.split(r"(?im)^\s*slide\s+\d+\s*-?\s*", rs)[1:]
-            slides = [p.strip() for p in parts if p.strip()][:SLIDES]
-            if slides: pptx = build_pptx(tuple(slides), chart_paths)
-    except Exception as e: st.error(f"Assembly failed: {e}")
-
-    return {
-        "preview_md": preview, "pdf": pdf, "slides": slides, "pptx": pptx,
-        "key": _key, "chart_count": len(chart_paths),
-        "chart_descriptions": list(chart_paths.keys())
-    }
+        agent=create_pandas_dataframe_agent(llm=llm,df=df,verbose=False,
+                                            allow_dangerous_code=True)
+        for d in chart_descs:
+            with plt.ioff():
+                try:
+                    agent.run(f"Create a {d} with matplotlib and save.")
+                    fig=plt.gcf()
+                    if fig.axes:
+                        p=Path(tempfile.gettempdir())/f"{uuid.uuid4()}.png"
+                        fig.savefig(p,dpi=300,bbox_inches="tight",
+                                    facecolor="white")
+                        chart_paths[d]=str(p)
+                    plt.close("all")
+                except: plt.close("all")
+
+    pdf=pptx=preview=None; slides=[]
+    if "rep" in outputs:
+        md=fix_bullet(outputs["rep"])
+        pdf=build_pdf(md,chart_paths)
+        preview=repl_tags(md,chart_paths,
+            lambda p:f'<img src="data:image/png;base64,{base64.b64encode(Path(p).read_bytes()).decode()}" style="max-width:100%;">')
+    if "pres" in outputs:
+        txt=fix_bullet(outputs["pres"])
+        parts=re.split(r"(?im)^\s*slide\s+\d+\s*-?\s*",txt)[1:][:SLIDES]
+        slides=[p.strip() for p in parts if p.strip()]
+        if slides: pptx=build_pptx(tuple(slides),chart_paths)
+    return {"preview":preview,"pdf":pdf,
+            "slides":slides,"pptx":pptx,
+            "charts":chart_paths,"key":key}
 
 # ─────────────────────────────────────────────────────────────────────────────
 # UI
 # ─────────────────────────────────────────────────────────────────────────────
-mode = st.radio("Choose output format:",
-                ["Report","Presentation","Both"], horizontal=True, index=2)
-
-st.subheader("📁 Upload Your Business Data")
-upl = st.file_uploader("Choose a CSV or Excel file",
-                       type=["csv","xlsx","xls"],
-                       help="Max 50 MB")
+mode=st.radio("Output:",["Report","Presentation","Both"],horizontal=True,index=2)
+st.subheader("📁 Upload Business Data")
+upl=st.file_uploader("CSV or Excel file",type=["csv","xlsx","xls"])
 
 if upl:
-    errs = validate_file_upload(upl)
-    if errs:
-        for e in errs: st.error(f"❌ {e}"); st.stop()
-    st.success(f"✅ File '{upl.name}' uploaded ({upl.size:,} bytes)")
-    try:
-        df_prev, prev_err = load_dataframe_safely(upl.getvalue(), upl.name)
-        if prev_err: st.error(prev_err); st.stop()
-        with st.expander("📊 Data Preview", expanded=False):
-            st.write(f"**Shape:** {df_prev.shape[0]} × {df_prev.shape[1]}")
-            st.dataframe(make_arrow_compatible(df_prev.head()))
-            st.write("**Column Information:**")
-            st.dataframe(arrow_safe_info(df_prev))
-    except Exception as e:
-        st.error(f"Preview error: {e}"); st.stop()
-
-ctx = st.text_area(
-    "Business context (optional)",
-    placeholder="e.g., Q4 2024 regional sales …",
-    help="Provide context for more relevant insights"
-)
-
-if not st.button("🚀 Generate Narrative", type="primary"): st.stop()
-if not upl: st.warning("Upload a file."); st.stop()
-
-bundle_key = sha1_bytes(b"".join([upl.getvalue(), mode.encode(), ctx.encode()]))
-if bundle_key in st.session_state.bundles:
-    bundle = st.session_state.bundles[bundle_key]
-    st.info("🔄 Using cached results.")
-else:
-    with st.spinner("🤖 Analyzing data & generating assets …"):
-        bundle = generate_assets(bundle_key, upl.getvalue(), upl.name, mode, ctx)
-        if bundle: st.session_state.bundles[bundle_key] = bundle
-if not bundle: st.error("Generation failed."); st.stop()
-
-if bundle["chart_count"]:
-    st.success(f"✅ Generated {bundle['chart_count']} chart(s).")
-
-if st.session_state.active_bundle_key != bundle["key"]:
-    st.session_state.slide_idx = 0
-    st.session_state.active_bundle_key = bundle["key"]
-
-# ─── Tabs
-if mode == "Both":
-    tab_rep, tab_pre = st.tabs(["📄 Report","📑 Slides"])
-elif mode == "Report":
-    tab_rep, tab_pre = st.container(), None
+    for e in validate_file_upload(upl): st.error(e)
+    if validate_file_upload(upl): st.stop()
+    df_prev,_=load_dataframe_safely(upl.getvalue(),upl.name)
+    with st.expander("Data Preview",False):
+        st.write(f"Shape: {df_prev.shape[0]} × {df_prev.shape[1]}")
+        st.dataframe(arrow_df(df_prev.head()))
+        st.dataframe(arrow_info(df_prev))
+
+ctx=st.text_area("Context (optional)")
+
+if not st.button("🚀 Generate",type="primary"): st.stop()
+if not upl: st.warning("Upload a file"); st.stop()
+
+bkey=sha1_bytes(b"".join([upl.getvalue(),mode.encode(),ctx.encode()]))
+if bkey in st.session_state.bundles:
+    bundle=st.session_state.bundles[bkey]
+    st.info("Using cached result")
 else:
-    tab_rep, tab_pre = None, st.container()
-
-# ─── Report tab
-if tab_rep:
-    with tab_rep:
-        st.subheader("📄 Generated Business Report")
-        if bundle["preview_md"]:
-            st.markdown(bundle["preview_md"], unsafe_allow_html=True)
-            col1,col2 = st.columns(2)
-            with col1:
-                if bundle["pdf"]:
-                    st.download_button("⬇️ Download PDF", bundle["pdf"],
-                                       "business_report.pdf","application/pdf")
-            with col2:
-                st.metric("Charts", bundle["chart_count"])
-        else:
-            st.warning("No report content generated.")
-
-# ─── Slides tab
-if tab_pre:
-    with tab_pre:
-        slides = bundle.get("slides", [])
+    with st.spinner("Generating assets …"):
+        bundle=make_assets(bkey,upl.getvalue(),upl.name,mode,ctx)
+        if bundle: st.session_state.bundles[bkey]=bundle
+if not bundle: st.error("Generation failed"); st.stop()
+
+if st.session_state.active_bundle_key!=bundle["key"]:
+    st.session_state.slide_idx=0
+    st.session_state.active_bundle_key=bundle["key"]
+
+if mode in ("Report","Both"):
+    with st.expander("📄 Report",True):
+        if bundle["preview"]:
+            st.markdown(bundle["preview"],unsafe_allow_html=True)
+            if bundle["pdf"]:
+                st.download_button("Download PDF",bundle["pdf"],
+                    "business_report.pdf","application/pdf")
+        else: st.warning("No report.")
+
+if mode in ("Presentation","Both"):
+    with st.expander("📑 Slides",True):
+        slides=bundle["slides"]
         if not slides:
-            st.warning("No slides generated.")
+            st.warning("No slides.")
         else:
-            st.session_state.slide_idx = max(
-                0, min(st.session_state.slide_idx, len(slides)-1))
-            idx = st.session_state.slide_idx
-            total = len(slides)
+            idx=st.session_state.slide_idx
+            idx=max(0,min(idx,len(slides)-1))
+            st.session_state.slide_idx=idx
+            total=len(slides)
             st.progress((idx+1)/total)
-            col1,col2,col3,col4,col5 = st.columns([1,1,2,1,1])
-            with col1:
-                if st.button("⬅️ Prev", disabled=idx==0):
-                    st.session_state.slide_idx -= 1; st.rerun()
-            with col2: st.write(f"**{idx+1} / {total}**")
-            with col3:
-                sel = st.selectbox("Jump", range(total), idx,
-                                   format_func=lambda x:f"Slide {x+1}")
-                if sel != idx:
-                    st.session_state.slide_idx = sel; st.rerun()
-            with col4:
-                if st.button("Next ➡️", disabled=idx>=total-1):
-                    st.session_state.slide_idx += 1; st.rerun()
-            with col5:
-                if st.button("🔊 Narrate"):
-                    txt = replace_chart_tags(slides[idx], {}, lambda _:"")
-                    txt = re.sub(r'^Slide \d+\s*[-:]?\s*','',txt, flags=re.I)
-                    narr = '. '.join(l.strip('•*- ') for l in txt.split('\n') if l.strip())
-                    with st.spinner("Generating narration…"):
-                        audio, mime = generate_tts_audio(narr)
-                        if audio:
-                            if "pcm" in mime.lower() or "l16" in mime.lower():
-                                audio = convert_pcm_to_wav(audio); mime="audio/wav"
-                            st.audio(audio, format=mime)
-                        else: st.error("Narration failed.")
+            cols=st.columns([1,1,2,1,1])
+            with cols[0]:
+                if st.button("⬅️",disabled=idx==0): 
+                    st.session_state.slide_idx-=1; st.rerun()
+            with cols[1]: st.write(f"{idx+1}/{total}")
+            with cols[2]:
+                j=st.selectbox("Jump",range(total),idx,
+                               format_func=lambda x:f"Slide {x+1}")
+                if j!=idx:
+                    st.session_state.slide_idx=j; st.rerun()
+            with cols[3]:
+                if st.button("➡️",disabled=idx>=total-1):
+                    st.session_state.slide_idx+=1; st.rerun()
+            with cols[4]:
+                if st.button("🔊"):
+                    txt=repl_tags(slides[idx],{},lambda _:"")
+                    txt=re.sub(r'^Slide \d+\s*[-:]?\s*','',txt,flags=re.I)
+                    narr='. '.join(l.strip('•*- ') for l in txt.split('\n') if l.strip())
+                    audio,mime=deepgram_tts(narr)
+                    if audio:
+                        if "pcm" in mime.lower() or "l16" in mime.lower():
+                            audio=pcm_to_wav(audio); mime="audio/wav"
+                        st.audio(audio,format=mime)
+                    else: st.error("Narration failed")
             st.divider()
-            title_line,*body = slides[idx].split('\n')
-            title = re.sub(r'^Slide \d+\s*[-:]?\s*','',title_line, flags=re.I).strip() or f"Slide {idx+1}"
-            st.markdown(f"### {title}")
-            for ln in body:
-                ln = ln.strip()
-                if not ln or TAG_RE.search(ln): continue
-                if ln[:1] in "•-*": st.markdown(ln)
-                else: st.markdown(f"• {ln}")
+
+            # display slide
+            raw=slides[idx]
+            title_line,*body=raw.split('\n')
+            title=re.sub(r'^Slide \d+\s*[-:]?\s*','',title_line,flags=re.I).strip()
+            st.markdown(f"### {title or f'Slide {idx+1}'}")
+            # bullet list
+            for l in body:
+                l=l.strip()
+                if not l or TAG_RE.search(l): continue
+                l = l.lstrip('•*- ')  # strip bullet char
+                st.markdown(f"- {l}")
+            # chart image
+            tg=[t for t in extract_chart_tags(raw) if t in bundle["charts"]]
+            if tg:
+                st.image(bundle["charts"][tg[0]],use_container_width=True)
             st.divider()
             if bundle["pptx"]:
-                st.download_button("⬇️ Download PPTX", bundle["pptx"],
-                                   "business_presentation.pptx",
-                                   "application/vnd.openxmlformats-officedocument.presentationml.presentation")
-            st.metric("Slides", total)
-
-# ─── Footer & cache clear
-with st.expander("💡 Tips for Better Results", False):
-    st.markdown("""
-*Use clean, well-structured data & provide business context for best insights.*
-""")
-
-if st.button("🧹 Clear Cache"):
-    st.session_state.bundles.clear()
-    st.session_state.slide_idx = 0
-    st.session_state.active_bundle_key = None
-    for f in Path(tempfile.gettempdir()).glob("*.png"):
-        try: f.unlink()
-        except: pass
-    st.success("Cache cleared."); st.rerun()
+                st.download_button("Download PPTX",bundle["pptx"],
+                    "business_presentation.pptx",
+                    "application/vnd.openxmlformats-officedocument.presentationml.presentation")