Update app.py

app.py

@@ -46,16 +46,18 @@ FONT_REG = FONT_DIR / "NotoSans-Regular.ttf"
 FONT_BLD = FONT_DIR / "NotoSans-Bold.ttf"
 FONT_FAM = "NotoSans"
 SLIDES = 7
-API_KEY = os.getenv("GEMINI_API_KEY")
 
+# Enhanced API key handling
+API_KEY = os.getenv("GEMINI_API_KEY")
 if not API_KEY:
-    st.error("Error: GEMINI_API_KEY environment variable is not set.")
+    st.error("⚠️ Error: GEMINI_API_KEY environment variable is not set.")
+    st.info("Please set your Google Gemini API key in the environment variables.")
     st.stop()
 
 try:
     GEM = genai.Client(api_key=API_KEY)
 except Exception as e:
-    st.error(f"Failed to initialize Google GenAI Client: {e}")
+    st.error(f"❌ Failed to initialize Google GenAI Client: {e}")
     st.stop()
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -67,15 +69,87 @@ if "slide_idx" not in st.session_state:
     st.session_state.slide_idx = 0
 if "active_bundle_key" not in st.session_state:
     st.session_state.active_bundle_key = None
+if "upload_errors" not in st.session_state:
+    st.session_state.upload_errors = []
 
 # ─────────────────────────────────────────────────────────────────────────────
 # HELPERS
 # ─────────────────────────────────────────────────────────────────────────────
 sha1_bytes = lambda b: hashlib.sha1(b).hexdigest()
 
+def validate_file_upload(uploaded_file):
+    """Validate uploaded file and return error messages if any."""
+    errors = []
+    
+    if uploaded_file is None:
+        errors.append("No file uploaded")
+        return errors
+    
+    # Check file size (limit to 50MB)
+    if uploaded_file.size > 50 * 1024 * 1024:
+        errors.append("File size exceeds 50MB limit")
+    
+    # Check file extension
+    allowed_extensions = ['.csv', '.xlsx', '.xls']
+    file_ext = Path(uploaded_file.name).suffix.lower()
+    if file_ext not in allowed_extensions:
+        errors.append(f"File type '{file_ext}' not supported. Please upload CSV or Excel files.")
+    
+    # Check if file has content
+    if uploaded_file.size == 0:
+        errors.append("File is empty")
+    
+    return errors
+
+def load_dataframe_safely(file_bytes, filename):
+    """Safely load DataFrame with proper error handling."""
+    try:
+        file_ext = Path(filename).suffix.lower()
+        
+        if file_ext == '.csv':
+            # Try different encodings for CSV
+            for encoding in ['utf-8', 'latin-1', 'cp1252']:
+                try:
+                    df = pd.read_csv(io.BytesIO(file_bytes), encoding=encoding)
+                    break
+                except UnicodeDecodeError:
+                    continue
+            else:
+                # If all encodings fail, try with error handling
+                df = pd.read_csv(io.BytesIO(file_bytes), encoding='utf-8', errors='replace')
+        
+        elif file_ext in ['.xlsx', '.xls']:
+            df = pd.read_excel(io.BytesIO(file_bytes))
+        
+        else:
+            raise ValueError(f"Unsupported file format: {file_ext}")
+        
+        # Basic DataFrame validation
+        if df.empty:
+            raise ValueError("The uploaded file contains no data")
+        
+        if len(df.columns) == 0:
+            raise ValueError("The uploaded file has no columns")
+        
+        # Clean column names
+        df.columns = df.columns.astype(str).str.strip()
+        
+        # Remove completely empty rows
+        df = df.dropna(how='all')
+        
+        if df.empty:
+            raise ValueError("All rows in the file are empty")
+        
+        return df, None
+        
+    except Exception as e:
+        return None, str(e)
 
 def fix_bullet(text: str) -> str:
     """Replace Windows-1252 bullets/dashes/quotes and strip other bad chars."""
+    if not isinstance(text, str):
+        return ""
+    
     subs = {
         "\x95": "•",
         "\x96": "-",
@@ -89,7 +163,6 @@ def fix_bullet(text: str) -> str:
         text = text.replace(bad, good)
     return re.sub(r"[\x80-\x9f]", "", text)
 
-
 def convert_pcm_to_wav(pcm_data: bytes, sample_rate=24000, channels=1, sample_width=2) -> bytes:
     """Wrap raw PCM data in a WAV container (in-memory)."""
     buf = io.BytesIO()
@@ -101,7 +174,6 @@ def convert_pcm_to_wav(pcm_data: bytes, sample_rate=24000, channels=1, sample_wi
     buf.seek(0)
     return buf.getvalue()
 
-
 # ─── Gemini TTS ──────────────────────────────────────────────────────────────
 @st.cache_data(show_spinner=False)
 def generate_tts_audio(text_to_speak: str):
@@ -127,97 +199,102 @@ def generate_tts_audio(text_to_speak: str):
     except Exception:
         return None, None
 
-
 # ─── Chart-tag regex (single source of truth) ────────────────────────────────
 TAG_RE = re.compile(
     r'[<\[]\s*generate_?chart\s*[:=]?\s*["\']?\s*([^>\]"\']+?)\s*["\']?\s*[>\]]',
     flags=re.IGNORECASE,
 )
 
-
 def extract_chart_tags(text: str) -> list[str]:
     """Return unique chart descriptors, order-preserved."""
+    if not isinstance(text, str):
+        return []
     return list(dict.fromkeys(TAG_RE.findall(text)))
 
-
 def replace_chart_tags(text: str, chart_map: dict[str, str], repl_func) -> str:
     """Replace chart placeholders with `repl_func(path)` if tag in chart_map."""
+    if not isinstance(text, str):
+        return ""
     return TAG_RE.sub(
         lambda m: repl_func(chart_map[m.group(1)]) if m.group(1) in chart_map else m.group(0),
         text,
     )
 
-
 # ─────────────────────────────────────────────────────────────────────────────
 # PDF & PPTX BUILDERS
 # ─────────────────────────────────────────────────────────────────────────────
 class PDF(FPDF, HTMLMixin):
     pass
 
-
 def build_pdf(markdown_src: str, chart_map: dict[str, str]) -> bytes:
-    markdown_src = fix_bullet(markdown_src).replace("•", "*")
-    markdown_src = replace_chart_tags(markdown_src, chart_map, lambda p: f'<img src="{p}">')
-    html = MarkdownIt("commonmark", {"breaks": True}).enable("table").render(markdown_src)
-
-    pdf = PDF()
-    pdf.set_auto_page_break(True, margin=15)
-    fonts_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)
-                fonts_added = True
-            except Exception:
-                pass
-    if fonts_added:
-        pdf.set_fallback_fonts([FONT_FAM])
-
-    pdf.add_page()
-    pdf.set_font(FONT_FAM if fonts_added else "Arial", "B", 18)
-    pdf.cell(0, 12, "AI-Generated Business Report", ln=True)
-    pdf.ln(3)
-    pdf.set_font(FONT_FAM if fonts_added else "Arial", "", 11)
-    pdf.write_html(html)
-    return bytes(pdf.output(dest="S"))
-
-
-def build_pptx(slides: tuple[str, ...], chart_map: dict[str, str]) -> bytes:
-    prs = Presentation()
-    layout = prs.slide_layouts[1]
-
-    for raw in slides:
-        if not raw.strip():
-            continue
-        raw_clean = fix_bullet(raw)
-        chart_tags = extract_chart_tags(raw_clean)
-
-        title, *body_lines = [ln.strip(" •-") for ln in raw_clean.splitlines() if ln.strip()]
-        slide = prs.slides.add_slide(layout)
-        slide.shapes.title.text = title or "Slide"
-
-        tf = slide.shapes.placeholders[1].text_frame
-        tf.clear()
-        tf.word_wrap = True
-        for line in body_lines:
-            if "generate_chart" in line.lower():
-                continue
-            p = tf.add_paragraph()
-            p.text = line
-            p.font.size = Pt(20)
-
-        for tag in chart_tags:
-            if tag in chart_map:
+    try:
+        markdown_src = fix_bullet(markdown_src).replace("•", "*")
+        markdown_src = replace_chart_tags(markdown_src, chart_map, lambda p: f'<img src="{p}">')
+        html = MarkdownIt("commonmark", {"breaks": True}).enable("table").render(markdown_src)
+
+        pdf = PDF()
+        pdf.set_auto_page_break(True, margin=15)
+        fonts_added = False
+        for style, ttf in [("", FONT_REG), ("B", FONT_BLD)]:
+            if ttf.exists():
                 try:
-                    slide.shapes.add_picture(chart_map[tag], Inches(1), Inches(3.5), width=Inches(8))
-                    break
+                    pdf.add_font(FONT_FAM, style, str(ttf), uni=True)
+                    fonts_added = True
                 except Exception:
                     pass
+        if fonts_added:
+            pdf.set_fallback_fonts([FONT_FAM])
+
+        pdf.add_page()
+        pdf.set_font(FONT_FAM if fonts_added else "Arial", "B", 18)
+        pdf.cell(0, 12, "AI-Generated Business Report", ln=True)
+        pdf.ln(3)
+        pdf.set_font(FONT_FAM if fonts_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""
 
-    bio = io.BytesIO()
-    prs.save(bio)
-    return bio.getvalue()
+def build_pptx(slides: tuple[str, ...], chart_map: dict[str, str]) -> bytes:
+    try:
+        prs = Presentation()
+        layout = prs.slide_layouts[1]
 
+        for raw in slides:
+            if not raw.strip():
+                continue
+            raw_clean = fix_bullet(raw)
+            chart_tags = extract_chart_tags(raw_clean)
+
+            title, *body_lines = [ln.strip(" •-") for ln in raw_clean.splitlines() if ln.strip()]
+            slide = prs.slides.add_slide(layout)
+            slide.shapes.title.text = title or "Slide"
+
+            tf = slide.shapes.placeholders[1].text_frame
+            tf.clear()
+            tf.word_wrap = True
+            for line in body_lines:
+                if "generate_chart" in line.lower():
+                    continue
+                p = tf.add_paragraph()
+                p.text = line
+                p.font.size = Pt(20)
+
+            for tag in chart_tags:
+                if tag in chart_map:
+                    try:
+                        slide.shapes.add_picture(chart_map[tag], Inches(1), Inches(3.5), width=Inches(8))
+                        break
+                    except Exception:
+                        pass
+
+        bio = io.BytesIO()
+        prs.save(bio)
+        return bio.getvalue()
+    except Exception as e:
+        st.error(f"PowerPoint generation failed: {e}")
+        return b""
 
 # ─────────────────────────────────────────────────────────────────────────────
 # SIMPLIFIED GENERATION LOGIC (without complex agents)
@@ -225,32 +302,41 @@ def build_pptx(slides: tuple[str, ...], chart_map: dict[str, str]) -> bytes:
 @st.cache_data(show_spinner=False)
 def generate_assets(_input_key, file_bytes, upl_name, mode, ctx):
     """Generate business assets using direct LLM calls and LangChain."""
-    # 1) Load data
+    
+    # 1) Load data with error handling
+    df, load_error = load_dataframe_safely(file_bytes, upl_name)
+    if load_error:
+        st.error(f"Failed to load data: {load_error}")
+        return None
+
+    # 2) Initialize LLM with error handling
     try:
-        df = (
-            pd.read_excel(io.BytesIO(file_bytes))
-            if upl_name.lower().endswith(".xlsx")
-            else pd.read_csv(io.BytesIO(file_bytes))
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash",
+            google_api_key=API_KEY,
+            temperature=0.1
         )
     except Exception as e:
-        st.error(f"Failed to load data: {e}")
+        st.error(f"Failed to initialize LLM: {e}")
         return None
 
-    # 2) Initialize LLM
-    llm = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
-        google_api_key=API_KEY,
-        temperature=0.1
-    )
-
-    # 3) Data context
-    data_ctx = {
-        "shape": df.shape,
-        "columns": list(df.columns),
-        "dtypes": df.dtypes.astype(str).to_dict(),
-        "sample": df.head(3).to_dict(),
-        "user_ctx": ctx or "General business analysis",
-    }
+    # 3) Data context with error handling
+    try:
+        # Get basic stats safely
+        numeric_cols = df.select_dtypes(include=['number']).columns.tolist()
+        sample_data = df.head(3).fillna("N/A").to_dict()
+        
+        data_ctx = {
+            "shape": df.shape,
+            "columns": list(df.columns),
+            "dtypes": df.dtypes.astype(str).to_dict(),
+            "sample": sample_data,
+            "numeric_columns": numeric_cols,
+            "user_ctx": ctx or "General business analysis",
+        }
+    except Exception as e:
+        st.error(f"Failed to analyze data structure: {e}")
+        return None
 
     # 4) Generate content based on mode
     outputs = {}
@@ -266,6 +352,7 @@ def generate_assets(_input_key, file_bytes, upl_name, mode, ctx):
           <generate_chart: "description of chart">
         
         Structure the report with clear sections and professional formatting.
+        Keep the analysis relevant to the business context provided.
         """
         try:
             report_response = llm.invoke(report_prompt)
@@ -297,55 +384,65 @@ def generate_assets(_input_key, file_bytes, upl_name, mode, ctx):
         st.error("No content was generated.")
         return None
 
-    # 5) Chart generation
+    # 5) Chart generation with enhanced error handling
     chart_descs = extract_chart_tags("\n".join(outputs.values()))
     chart_paths = {}
 
     if chart_descs:
-        chart_agent = create_pandas_dataframe_agent(
-            llm=llm,
-            df=df,
-            verbose=False,
-            allow_dangerous_code=True,
-        )
-        for desc in chart_descs:
-            with plt.ioff(): # Turn off interactive plotting
-                try:
-                    chart_agent.run(
-                        f"Create a {desc} with matplotlib. Use clear labels & title; call plt.savefig when done."
-                    )
-                    fig = plt.gcf()
-                    if fig.get_axes():
-                        path = Path(tempfile.gettempdir()) / f"chart_{uuid.uuid4()}.png"
-                        fig.savefig(path, dpi=300, bbox_inches="tight", facecolor="white")
-                        chart_paths[desc] = str(path)
-                    plt.close("all")
-                except Exception as e:
-                    print(f"Chart generation for '{desc}' failed: {e}") # For debugging
-                    plt.close("all") # Ensure figure is closed even on error
-                    pass
+        try:
+            chart_agent = create_pandas_dataframe_agent(
+                llm=llm,
+                df=df,
+                verbose=False,
+                allow_dangerous_code=True,
+            )
+            
+            for desc in chart_descs:
+                with plt.ioff():  # Turn off interactive plotting
+                    try:
+                        chart_agent.run(
+                            f"Create a {desc} with matplotlib. Use clear labels & title; call plt.savefig when done."
+                        )
+                        fig = plt.gcf()
+                        if fig.get_axes():
+                            path = Path(tempfile.gettempdir()) / f"chart_{uuid.uuid4()}.png"
+                            fig.savefig(path, dpi=300, bbox_inches="tight", facecolor="white")
+                            chart_paths[desc] = str(path)
+                        plt.close("all")
+                    except Exception as e:
+                        print(f"Chart generation for '{desc}' failed: {e}")
+                        plt.close("all")
+                        pass
+        except Exception as e:
+            st.warning(f"Chart generation system failed: {e}")
 
     # 6) Assemble outputs
     pdf_bytes = pptx_bytes = preview_md = None
     slides = []
 
     if "ReportAgent" in outputs:
-        md_raw = fix_bullet(outputs["ReportAgent"])
-        pdf_bytes = build_pdf(md_raw, chart_paths)
-        preview_md = replace_chart_tags(
-            md_raw,
-            chart_paths,
-            lambda p: f'<img src="data:image/png;base64,{base64.b64encode(open(p,"rb").read()).decode()}" style="max-width:100%;">',
-        )
+        try:
+            md_raw = fix_bullet(outputs["ReportAgent"])
+            pdf_bytes = build_pdf(md_raw, chart_paths)
+            preview_md = replace_chart_tags(
+                md_raw,
+                chart_paths,
+                lambda p: f'<img src="data:image/png;base64,{base64.b64encode(open(p,"rb").read()).decode()}" style="max-width:100%;">',
+            )
+        except Exception as e:
+            st.error(f"Report processing failed: {e}")
 
     if "PresentationAgent" in outputs:
-        raw_slides_text = fix_bullet(outputs["PresentationAgent"])
-        # robust splitter – starts at lines beginning with "Slide n"
-        parts = re.split(r"(?im)^\s*slide\s+\d+\s*-?", raw_slides_text)[1:]
-        slides = [p.strip() for p in parts if p.strip()]
+        try:
+            raw_slides_text = fix_bullet(outputs["PresentationAgent"])
+            # robust splitter – starts at lines beginning with "Slide n"
+            parts = re.split(r"(?im)^\s*slide\s+\d+\s*-?", raw_slides_text)[1:]
+            slides = [p.strip() for p in parts if p.strip()]
 
-        if slides:
-            pptx_bytes = build_pptx(tuple(slides), chart_paths)
+            if slides:
+                pptx_bytes = build_pptx(tuple(slides), chart_paths)
+        except Exception as e:
+            st.error(f"Presentation processing failed: {e}")
 
     return {
         "preview_md": preview_md,
@@ -356,19 +453,67 @@ def generate_assets(_input_key, file_bytes, upl_name, mode, ctx):
         "chart_count": len(chart_paths),
     }
 
-
 # ─────────────────────────────────────────────────────────────────────────────
 # UI
 # ─────────────────────────────────────────────────────────────────────────────
 mode = st.radio("Choose output format:", ["Report", "Presentation", "Both"], horizontal=True, index=2)
-upl = st.file_uploader("Upload business data", ["csv", "xlsx"])
-ctx = st.text_area("Business context (optional)")
+
+# Enhanced file uploader with validation
+st.subheader("📁 Upload Your Business Data")
+upl = st.file_uploader(
+    "Choose a CSV or Excel file", 
+    type=["csv", "xlsx", "xls"],
+    help="Supported formats: CSV, Excel (.xlsx, .xls). Maximum file size: 50MB"
+)
+
+# File validation
+if upl is not None:
+    upload_errors = validate_file_upload(upl)
+    
+    if upload_errors:
+        for error in upload_errors:
+            st.error(f"❌ {error}")
+        st.stop()
+    else:
+        # Show file info if valid
+        st.success(f"✅ File '{upl.name}' uploaded successfully ({upl.size:,} bytes)")
+        
+        # Preview data
+        try:
+            df_preview, preview_error = load_dataframe_safely(upl.getvalue(), upl.name)
+            if preview_error:
+                st.error(f"❌ Error reading file: {preview_error}")
+                st.stop()
+            else:
+                with st.expander("📊 Data Preview", expanded=False):
+                    st.write(f"**Shape:** {df_preview.shape[0]} rows × {df_preview.shape[1]} columns")
+                    st.write("**Sample Data:**")
+                    st.dataframe(df_preview.head())
+                    
+                    # Show column info
+                    col_info = pd.DataFrame({
+                        'Column': df_preview.columns,
+                        'Type': df_preview.dtypes,
+                        'Non-Null Count': df_preview.count(),
+                        'Null Count': df_preview.isnull().sum()
+                    })
+                    st.write("**Column Information:**")
+                    st.dataframe(col_info)
+        except Exception as e:
+            st.error(f"❌ Error previewing file: {e}")
+            st.stop()
+
+ctx = st.text_area(
+    "Business context (optional)", 
+    placeholder="e.g., This is sales data for Q4 2024, focusing on regional performance...",
+    help="Provide context about your data to get more relevant insights"
+)
 
 if not st.button("🚀 Generate Narrative", type="primary"):
     st.stop()
 
 if not upl:
-    st.warning("Please upload a CSV or XLSX file.")
+    st.warning("⚠️ Please upload a CSV or Excel file to continue.")
     st.stop()
 
 # Generate unique bundle key for caching
@@ -377,6 +522,7 @@ bundle_key = sha1_bytes(b"".join([upl.getvalue(), mode.encode(), ctx.encode()]))
 # Check if we already have this bundle cached
 if bundle_key in st.session_state.bundles:
     bundle = st.session_state.bundles[bundle_key]
+    st.info("🔄 Using cached results for this configuration.")
 else:
     with st.spinner("🤖 AI is analyzing your data and generating content..."):
         bundle = generate_assets(bundle_key, upl.getvalue(), upl.name, mode, ctx)
@@ -384,6 +530,7 @@ else:
             st.session_state.bundles[bundle_key] = bundle
 
 if not bundle:
+    st.error("❌ Failed to generate content. Please try again.")
     st.stop()
 
 if bundle.get("chart_count"):