Upload folder using huggingface_hub

builders/build_docx.py

@@ -347,6 +347,25 @@ def build_document(data: dict, output_path: str) -> None:
 
     _swot_section(doc, data)
     _trends_section(doc, data)
+    
+    # Visualizations Section
+    try:
+        from builders.chart_builder import generate_all_charts
+        charts = generate_all_charts(data)
+        if any(charts.values()):
+            _add_heading(doc, "Financial Visualizations", 1)
+            if charts.get("revenue_net_income"):
+                _add_heading(doc, "Revenue & Net Income Trend", 2)
+                doc.add_picture(charts["revenue_net_income"], width=Inches(6.0))
+            if charts.get("margins"):
+                _add_heading(doc, "Profitability Margins", 2)
+                doc.add_picture(charts["margins"], width=Inches(6.0))
+            if charts.get("cash_flow"):
+                _add_heading(doc, "Cash Flow & CAPEX", 2)
+                doc.add_picture(charts["cash_flow"], width=Inches(6.0))
+    except Exception as e:
+        print(f"Warning: Could not generate DOCX charts: {e}", file=sys.stderr)
+
     _ratio_section(doc, data)
     _dupont_section(doc, data)
     _peer_section(doc, data)

builders/build_pptx.py

@@ -382,7 +382,33 @@ def build_presentation(data: Dict, output_path: str):
             p_c.line_spacing = 1.2
 
     # ==========================================
-    # SLIDE 6: Key Synthesis Insights
+    # SLIDE 6: Financial Visualizations
+    # ==========================================
+    try:
+        from builders.chart_builder import generate_all_charts
+        charts = generate_all_charts(data)
+        
+        for chart_key, title in [
+            ("revenue_net_income", "Revenue & Net Income Trend"),
+            ("margins", "Profitability Margins"),
+            ("cash_flow", "Cash Flow & CAPEX Overview")
+        ]:
+            if charts.get(chart_key):
+                slide_chart = prs.slides.add_slide(blank_layout)
+                _apply_theme_decorations(slide_chart, prs)
+                _add_slide_title(slide_chart, title)
+                
+                # Add picture centrally
+                slide_chart.shapes.add_picture(
+                    charts[chart_key],
+                    Inches(1.5), Inches(1.5), width=Inches(10.0)
+                )
+    except Exception as e:
+        import sys
+        print(f"Warning: Could not generate PPTX charts: {e}", file=sys.stderr)
+
+    # ==========================================
+    # SLIDE 7: Key Synthesis Insights
     # ==========================================
     insights_list = data.get("key_insights", [])
     if insights_list:

builders/chart_builder.py

@@ -0,0 +1,125 @@
+import io
+import matplotlib
+matplotlib.use('Agg') # Headless mode
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
+import numpy as np
+
+# Set seaborn theme for professional looks
+sns.set_theme(style="whitegrid", palette="muted")
+plt.rcParams['font.family'] = 'sans-serif'
+plt.rcParams['font.sans-serif'] = ['Arial', 'Helvetica', 'DejaVu Sans']
+
+def _create_bytes_img(fig):
+    buf = io.BytesIO()
+    fig.savefig(buf, format='png', bbox_inches='tight', dpi=150)
+    buf.seek(0)
+    plt.close(fig)
+    return buf
+
+def generate_revenue_net_income_chart(data: dict) -> io.BytesIO:
+    years = data.get("years", [])
+    if not years:
+        return None
+    
+    rev = data.get("income_statement", {}).get("revenue", [])
+    ni = data.get("income_statement", {}).get("net_income", [])
+    
+    # Pad to match years
+    rev = (rev + [0]*len(years))[:len(years)]
+    ni = (ni + [0]*len(years))[:len(years)]
+    
+    # Fill None with 0 for plotting
+    rev = [r if r is not None else 0 for r in rev]
+    ni = [n if n is not None else 0 for n in ni]
+    
+    fig, ax1 = plt.subplots(figsize=(8, 4.5))
+    
+    x = np.arange(len(years))
+    width = 0.35
+    
+    ax1.bar(x - width/2, rev, width, label='Revenue', color='#1F4E78')
+    ax1.bar(x + width/2, ni, width, label='Net Income', color='#549E39')
+    
+    ax1.set_ylabel(f"Amount ({data.get('currency', 'INR')} {data.get('units_label', 'Crores')})")
+    ax1.set_title("Revenue & Net Income Trend")
+    ax1.set_xticks(x)
+    ax1.set_xticklabels(years)
+    ax1.legend()
+    
+    return _create_bytes_img(fig)
+
+def generate_margins_chart(data: dict) -> io.BytesIO:
+    years = data.get("years", [])
+    if not years:
+        return None
+        
+    ratios = data.get("ratios", {})
+    gm = ratios.get("gross_margin", [])
+    om = ratios.get("operating_margin", [])
+    nm = ratios.get("net_margin", [])
+    
+    gm = [(g*100) if g is not None else 0 for g in (gm + [0]*len(years))[:len(years)]]
+    om = [(o*100) if o is not None else 0 for o in (om + [0]*len(years))[:len(years)]]
+    nm = [(n*100) if n is not None else 0 for n in (nm + [0]*len(years))[:len(years)]]
+    
+    fig, ax = plt.subplots(figsize=(8, 4.5))
+    x = np.arange(len(years))
+    
+    ax.plot(x, gm, marker='o', linewidth=2, label='Gross Margin %', color='#1F4E78')
+    ax.plot(x, om, marker='s', linewidth=2, label='Operating Margin %', color='#455F51')
+    ax.plot(x, nm, marker='^', linewidth=2, label='Net Margin %', color='#549E39')
+    
+    ax.set_ylabel("Margin (%)")
+    ax.set_title("Profitability Margins Trend")
+    ax.set_xticks(x)
+    ax.set_xticklabels(years)
+    
+    # Add value labels
+    for i in range(len(years)):
+        if nm[i] != 0:
+            ax.annotate(f"{nm[i]:.1f}%", (x[i], nm[i]), textcoords="offset points", xytext=(0,10), ha='center')
+            
+    ax.legend()
+    
+    return _create_bytes_img(fig)
+
+def generate_cash_flow_chart(data: dict) -> io.BytesIO:
+    years = data.get("years", [])
+    if not years:
+        return None
+        
+    cf = data.get("cash_flow", {})
+    ocf = cf.get("cash_from_operations", [])
+    capex = cf.get("capex", [])
+    fcf = cf.get("free_cash_flow", [])
+    
+    ocf = [o if o is not None else 0 for o in (ocf + [0]*len(years))[:len(years)]]
+    # Capex is usually negative, let's plot absolute value for magnitude comparison
+    capex = [abs(c) if c is not None else 0 for c in (capex + [0]*len(years))[:len(years)]]
+    fcf = [f if f is not None else 0 for f in (fcf + [0]*len(years))[:len(years)]]
+    
+    fig, ax = plt.subplots(figsize=(8, 4.5))
+    x = np.arange(len(years))
+    width = 0.25
+    
+    ax.bar(x - width, ocf, width, label='Operating Cash Flow', color='#1F4E78')
+    ax.bar(x, capex, width, label='CAPEX (Abs)', color='#C00000')
+    ax.bar(x + width, fcf, width, label='Free Cash Flow', color='#549E39')
+    
+    ax.set_ylabel(f"Amount ({data.get('currency', 'INR')} {data.get('units_label', 'Crores')})")
+    ax.set_title("Cash Flow & CAPEX Overview")
+    ax.set_xticks(x)
+    ax.set_xticklabels(years)
+    ax.legend()
+    
+    return _create_bytes_img(fig)
+
+def generate_all_charts(data: dict) -> dict:
+    """Returns a dict mapping chart names to BytesIO pngs."""
+    return {
+        "revenue_net_income": generate_revenue_net_income_chart(data),
+        "margins": generate_margins_chart(data),
+        "cash_flow": generate_cash_flow_chart(data)
+    }

config.py

@@ -15,6 +15,7 @@ GEMINI_API_KEY: str = os.environ.get("GEMINI_API_KEY", "")
 CLAUDE_API_KEY: str = os.environ.get("CLAUDE_API_KEY", "")
 OPENAI_API_KEY: str = os.environ.get("OPENAI_API_KEY", "")
 GROQ_API_KEY: str   = os.environ.get("GROQ_API_KEY", "")
+NVIDIA_API_KEY: str = os.environ.get("NVIDIA_API_KEY", "")
 
 # ── Data settings ─────────────────────────────────────────────────────────────
 DEFAULT_YEARS: int = 5
@@ -35,6 +36,7 @@ GEMINI_MODEL: str  = "gemini-2.0-flash"
 CLAUDE_MODEL: str  = "claude-3-5-haiku-20241022"
 OPENAI_MODEL: str  = "gpt-4o-mini"
 GROQ_MODEL: str    = "llama-3.3-70b-versatile"    # free, high-quality
+NVIDIA_MODEL: str  = "meta/llama-3.1-405b-instruct"
 
 # ── App metadata ──────────────────────────────────────────────────────────────
 APP_NAME: str = "Financial Analyzer"

pipeline/analyst.py

@@ -13,7 +13,7 @@ from pathlib import Path
 from typing import Dict, List, Optional
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
-from config import GEMINI_API_KEY, CLAUDE_API_KEY, GEMINI_MODEL, CLAUDE_MODEL, OPENAI_API_KEY, OPENAI_MODEL, GROQ_API_KEY, GROQ_MODEL
+from config import GEMINI_API_KEY, CLAUDE_API_KEY, GEMINI_MODEL, CLAUDE_MODEL, OPENAI_API_KEY, OPENAI_MODEL, GROQ_API_KEY, GROQ_MODEL, NVIDIA_API_KEY, NVIDIA_MODEL
 
 
 # ── Formatting helpers ────────────────────────────────────────────────────────
@@ -317,12 +317,13 @@ def _gemini_generate(context: str, section: str, log_fn=None) -> str:
             import google.generativeai as genai_old
             genai_old.configure(api_key=GEMINI_API_KEY)
             model = genai_old.GenerativeModel(model_name=GEMINI_MODEL, system_instruction=SYSTEM_PROMPT)
-            response = model.generate_content(f"FINANCIAL DATA:\n{context}\n\nTASK:\n{SECTION_PROMPTS[section]}")
+            response = model.generate_content(prompt)
             return response.text.strip()
         except Exception as e2:
-            return f"[Gemini error for {section}: {e2}]"
+            if log_fn: log_fn(f"[Warning] Gemini failed for {section}: {str(e2)[:80]}")
+            return None
 
-    return f"[Gemini unavailable for {section}: API key missing]"
+    return None
 
 
 
@@ -344,7 +345,8 @@ def _openai_generate(context: str, section: str, log_fn=None) -> str:
         )
         return resp.choices[0].message.content.strip()
     except Exception as e:
-        return f"[ChatGPT error for {section}: {e}]"
+        if log_fn: log_fn(f"[Warning] ChatGPT failed for {section}: {str(e)[:80]}")
+        return None
 
 
 # ── Groq (free — Llama 3.3 70B) ──────────────────────────────────────────────
@@ -369,7 +371,34 @@ def _groq_generate(context: str, section: str, log_fn=None) -> str:
         )
         return resp.choices[0].message.content.strip()
     except Exception as e:
-        return f"[Groq error for {section}: {e}]"
+        if log_fn: log_fn(f"[Warning] Groq failed for {section}: {str(e)[:80]}")
+        return None
+
+
+# ── NVIDIA NIM (Llama 3.1 405B) ──────────────────────────────────────────────
+
+def _nvidia_generate(context: str, section: str, log_fn=None) -> Optional[str]:
+    """Generate using NVIDIA NIM OpenAI-compatible API."""
+    try:
+        from openai import OpenAI
+        client = OpenAI(
+            api_key=NVIDIA_API_KEY,
+            base_url="https://integrate.api.nvidia.com/v1",
+        )
+        prompt = f"FINANCIAL DATA:\n{context}\n\nTASK:\n{SECTION_PROMPTS[section]}"
+        resp = client.chat.completions.create(
+            model=NVIDIA_MODEL,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user",   "content": prompt},
+            ],
+            temperature=0.2,
+            max_tokens=1024,
+        )
+        return resp.choices[0].message.content.strip()
+    except Exception as e:
+        if log_fn: log_fn(f"[Warning] NVIDIA NIM failed for {section}: {str(e)[:80]}")
+        return None
 
 
 # ── Claude ────────────────────────────────────────────────────────────────────
@@ -387,7 +416,8 @@ def _claude_generate(context: str, section: str, log_fn=None) -> str:
         )
         return message.content[0].text.strip()
     except Exception as e:
-        return f"[Claude error for {section}: {e}]"
+        if log_fn: log_fn(f"[Warning] Claude failed for {section}: {str(e)[:80]}")
+        return None
 
 
 # ── Parse structured sections ─────────────────────────────────────────────────
@@ -462,37 +492,76 @@ def generate_narrative(
     use_claude = "claude" in models and bool(CLAUDE_API_KEY)
     use_openai = "openai" in models and bool(OPENAI_API_KEY)
     use_groq   = "groq"   in models and bool(GROQ_API_KEY)
+    use_nvidia = "nvidia" in models and bool(NVIDIA_API_KEY)
 
-    if not use_gemini and not use_claude and not use_openai and not use_groq:
+    if not any([use_gemini, use_claude, use_openai, use_groq, use_nvidia]):
         log("No AI models configured. Running data-only analysis (no narrative).")
         return _empty_narrative()
 
     context = _build_context(data, meta)
-    active = [m for m, ok in [("Gemini",use_gemini),("Claude",use_claude),("ChatGPT",use_openai),("Groq (Llama)",use_groq)] if ok]
+    active = [m for m, ok in [("Gemini",use_gemini),("Claude",use_claude),("ChatGPT",use_openai),("Groq",use_groq),("NVIDIA",use_nvidia)] if ok]
     log(f"Generating AI narrative ({', '.join(active)}) ...")
 
+    def _synthesize_drafts(section: str, drafts: Dict[str, str]) -> str:
+        """Use the best available model to merge drafts into a single consensus response."""
+        # Pick the synthesizer based on perceived quality/capability
+        synthesizer = None
+        if use_openai:  synthesizer = ("ChatGPT", _openai_generate)
+        elif use_claude: synthesizer = ("Claude", _claude_generate)
+        elif use_nvidia: synthesizer = ("NVIDIA", _nvidia_generate)
+        elif use_gemini: synthesizer = ("Gemini", _gemini_generate)
+        elif use_groq:   synthesizer = ("Groq", _groq_generate)
+        
+        if not synthesizer:
+            return list(drafts.values())[0]
+
+        name, fn = synthesizer
+        log(f"  > Synthesizing {len(drafts)} drafts using {name}...")
+        
+        draft_text = "\n\n".join([f"--- Draft from {agent} ---\n{text}" for agent, text in drafts.items()])
+        prompt = SYNTHESIS_PROMPT.format(section=section) + "\n\n" + draft_text
+        
+        # We reuse the context parameter to pass the prompt, and bypass the section wrapping by mocking it
+        # Actually, let's just create a custom direct call for synthesis to avoid section wrapping issues.
+        # But to reuse the functions easily, we can temporarily override the SECTION_PROMPTS.
+        original_prompt = SECTION_PROMPTS.get(section, "")
+        SECTION_PROMPTS[section] = prompt
+        try:
+            res = fn("", section) # Context empty because prompt contains everything
+        finally:
+            SECTION_PROMPTS[section] = original_prompt
+            
+        if res: return res
+        
+        # If synthesis fails, fallback to simple concatenation
+        return "\n\n".join([f"[{a}]\n{t}" for a, t in drafts.items()])
+
+    import concurrent.futures
+
     def gen(section: str) -> str:
-        results = []
-        if use_gemini:
-            log(f"  Gemini: {section} ...")
-            results.append(("Gemini", _gemini_generate(context, section, log_fn)))
-        if use_claude:
-            log(f"  Claude: {section} ...")
-            results.append(("Claude", _claude_generate(context, section, log_fn)))
-        if use_openai:
-            log(f"  ChatGPT: {section} ...")
-            results.append(("ChatGPT", _openai_generate(context, section, log_fn)))
-        if use_groq:
-            log(f"  Groq (Llama 3.3): {section} ...")
-            results.append(("Groq/Llama", _groq_generate(context, section, log_fn)))
-
-        if len(results) == 1:
-            return results[0][1]
-        # Multiple models — combine with attribution
-        combined = ""
-        for name, text in results:
-            combined += f"[{name}]\n{text}\n\n"
-        return combined.strip()
+        tasks = {}
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            if use_gemini: tasks[executor.submit(_gemini_generate, context, section)] = "Gemini"
+            if use_claude: tasks[executor.submit(_claude_generate, context, section)] = "Claude"
+            if use_openai: tasks[executor.submit(_openai_generate, context, section)] = "ChatGPT"
+            if use_groq:   tasks[executor.submit(_groq_generate, context, section)] = "Groq"
+            if use_nvidia: tasks[executor.submit(_nvidia_generate, context, section)] = "NVIDIA"
+            
+            drafts = {}
+            for future in concurrent.futures.as_completed(tasks):
+                name = tasks[future]
+                try:
+                    res = future.result()
+                    if res: drafts[name] = res
+                except Exception as e:
+                    if log_fn: log_fn(f"[Warning] {name} thread failed: {e}")
+
+        if len(drafts) == 0:
+            return f"[{section}: All AI models failed to generate a response]"
+        elif len(drafts) == 1:
+            return list(drafts.values())[0]
+        else:
+            return _synthesize_drafts(section, drafts)
 
     # Generate all sections
     log("  Generating executive summary …")

pipeline/key_validator.py

@@ -133,9 +133,34 @@ def validate_groq(key: str) -> tuple:
         return False, f"Error: {msg[:80]}"
 
 
-def check_any_ai_model(gemini_key: str = "", claude_key: str = "", openai_key: str = "", groq_key: str = "") -> tuple:
+def validate_nvidia(key: str) -> tuple:
+    """Test NVIDIA NIM key with a minimal chat completion."""
+    if not key or key.strip() in ("", "your_nvidia_key_here"):
+        return False, "No key entered."
+    try:
+        from openai import OpenAI
+        client = OpenAI(
+            api_key=key.strip(),
+            base_url="https://integrate.api.nvidia.com/v1",
+        )
+        resp = client.chat.completions.create(
+            model="meta/llama-3.1-405b-instruct",
+            messages=[{"role": "user", "content": "Reply with the single word: OK"}],
+            max_tokens=5,
+        )
+        text = resp.choices[0].message.content.strip() if resp.choices else ""
+        return True, f"Valid ✓  (NVIDIA NIM, response: '{text[:20]}')"
+    except Exception as e:
+        msg = str(e)
+        if "401" in msg or "invalid_api_key" in msg.lower() or "unauthorized" in msg.lower():
+            return False, "Invalid NVIDIA API key. Check and re-enter."
+        return False, f"Error: {msg[:80]}"
+
+
+def check_any_ai_model(gemini_key: str = "", claude_key: str = "", openai_key: str = "", groq_key: str = "", nvidia_key: str = "") -> tuple:
     """Quickly check if at least one AI model is usable."""
     checks = [
+        ("nvidia", nvidia_key, validate_nvidia),
         ("groq",   groq_key,   validate_groq),
         ("gemini", gemini_key, validate_gemini),
         ("claude", claude_key, validate_claude),
@@ -150,6 +175,7 @@ def check_any_ai_model(gemini_key: str = "", claude_key: str = "", openai_key: s
     return False, (
         "No working AI model key found.\n\n"
         "Free options (no credit card needed):\n"
+        "  • NVIDIA NIM (Free credits) → build.nvidia.com\n"
         "  • Groq (Llama 3.3 70B) → console.groq.com\n"
         "  • Gemini → aistudio.google.com\n\n"
         "Paid options:\n"

requirements.txt

@@ -10,3 +10,5 @@ python-docx>=1.1.0
 pandas>=2.0.0
 Pillow>=10.0.0
 yfinance>=0.2.40
+matplotlib
+seaborn

web_app/app.py

@@ -134,6 +134,18 @@ st.sidebar.markdown("""
 </div>
 """, unsafe_allow_html=True)
 
+st.sidebar.markdown("""
+**NVIDIA NIM** *(Llama 3.1 405B / Nemotron)*  
+<a href='https://build.nvidia.com/explore/discover' target='_blank' style='font-size:0.75rem;color:#34D399;'>Get free key → build.nvidia.com</a>
+""", unsafe_allow_html=True)
+nvidia_key = st.sidebar.text_input(
+    "NVIDIA API Key", type="password",
+    placeholder="nvapi-…",
+    value=os.environ.get("NVIDIA_API_KEY", ""),
+    help="Free credits available. Sign up at build.nvidia.com.",
+    key="inp_nvidia"
+)
+
 st.sidebar.markdown("""
 **Groq** *(Llama 3.3 70B — fast & free)*  
 <a href='https://console.groq.com/keys' target='_blank' style='font-size:0.75rem;color:#34D399;'>Get free key → console.groq.com</a>
@@ -200,7 +212,36 @@ with col1:
     st.markdown("<div class='glass-card'>", unsafe_allow_html=True)
     st.subheader("Analysis Parameters")
     
-    ticker_input = st.text_input("Company Name or Stock Ticker", placeholder="e.g. TCS, Reliance, AAPL, MSFT, INFY", help="Resolves directly via yfinance and FMP")
+    # ── Ticker Search & Suggestion Logic ──
+    search_col1, search_col2 = st.columns([3, 1])
+    with search_col1:
+        search_query = st.text_input("Search Company Name or Ticker", placeholder="e.g. TCS, Reliance, AAPL, MSFT")
+    with search_col2:
+        st.markdown("<div style='margin-top:28px;'></div>", unsafe_allow_html=True)
+        search_clicked = st.button("🔍 Find", use_container_width=True)
+
+    ticker_input = search_query # default if no suggestions
+
+    if search_clicked and search_query:
+        with st.spinner("Searching..."):
+            try:
+                import yfinance as yf
+                res = yf.Search(search_query, max_results=8)
+                quotes = [q for q in res.quotes if q.get("quoteType") in ("EQUITY", "MUTUALFUND", "ETF")]
+                st.session_state["ticker_suggestions"] = quotes
+            except Exception:
+                st.session_state["ticker_suggestions"] = []
+
+    if "ticker_suggestions" in st.session_state and st.session_state["ticker_suggestions"]:
+        options = {}
+        for q in st.session_state["ticker_suggestions"]:
+            name = q.get('longname') or q.get('shortname') or q.get('symbol')
+            label = f"{name} ({q['symbol']}) - {q.get('exchange', 'Unknown')}"
+            options[label] = q['symbol']
+            
+        options[f"Use exact input: '{search_query}'"] = search_query
+        selected_label = st.selectbox("Confirm Company:", list(options.keys()))
+        ticker_input = options[selected_label]
     
     col_years, col_refresh = st.columns([1, 1])
     with col_years:
@@ -219,8 +260,17 @@ with col1:
     _hint = "<span style='font-size:0.72rem;color:#9CA3AF;'>(add key in sidebar →)</span>"
 
     engines = []
+    
+    if st.checkbox(
+        "🆓 NVIDIA NIM — Llama 3.1 405B",
+        value=bool(nvidia_key),
+        disabled=not nvidia_key,
+        help="Free credits. Get key at build.nvidia.com"
+    ):
+        engines.append("nvidia")
+
     if st.checkbox(
-        "🆓 Groq — Llama 3.3 70B (recommended)",
+        "🆓 Groq — Llama 3.3 70B",
         value=bool(groq_key),
         disabled=not groq_key,
         help="Free. Get key at console.groq.com"
@@ -284,24 +334,30 @@ if start_btn:
         config.CLAUDE_API_KEY = claude_key
         config.OPENAI_API_KEY = openai_key
         config.GROQ_API_KEY   = groq_key
+        config.NVIDIA_API_KEY = nvidia_key
         
         pipeline.analyst.GEMINI_API_KEY = gemini_key
         pipeline.analyst.CLAUDE_API_KEY = claude_key
         pipeline.analyst.OPENAI_API_KEY = openai_key
         pipeline.analyst.GROQ_API_KEY   = groq_key
+        pipeline.analyst.NVIDIA_API_KEY = nvidia_key
         
         pipeline.key_validator.GEMINI_API_KEY = gemini_key
         pipeline.key_validator.CLAUDE_API_KEY = claude_key
         pipeline.key_validator.OPENAI_API_KEY = openai_key
+        pipeline.key_validator.GROQ_API_KEY   = groq_key
+        pipeline.key_validator.NVIDIA_API_KEY = nvidia_key
 
         # Push into environment for any sub-process
         for k, v in [("GEMINI_API_KEY", gemini_key), ("CLAUDE_API_KEY", claude_key),
-                     ("OPENAI_API_KEY", openai_key), ("GROQ_API_KEY", groq_key)]:
+                     ("OPENAI_API_KEY", openai_key), ("GROQ_API_KEY", groq_key), 
+                     ("NVIDIA_API_KEY", nvidia_key)]:
             if v: os.environ[k] = v
         
         # Validate that selected engines have keys
         failed_validation = False
         engine_key_map = {
+            "nvidia": (nvidia_key, "NVIDIA"),
             "groq":   (groq_key,   "Groq"),
             "gemini": (gemini_key, "Gemini"),
             "claude": (claude_key, "Claude"),
@@ -406,30 +462,54 @@ if start_btn:
                 # ── Generate download buttons in UI
                 with download_container.container():
                     st.success("Download ready!")
-                    col_btn1, col_btn2, col_btn3 = st.columns(3)
+                    dl_col1, dl_col2, dl_col3, dl_col4 = st.columns(4)
+                    
+                    download_files = []
                     
                     if excel_bytes:
-                        col_btn1.download_button(
-                            label="📥 Download Excel Workbook",
+                        dl_col1.download_button(
+                            label="📥 Download Excel",
                             data=excel_bytes,
-                            file_name=f"{ticker_safe}_Analysis_{timestamp_suffix}.xlsx",
-                            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                            file_name=f"{ticker_safe}_analysis.xlsx",
+                            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                            use_container_width=True
                         )
+                        download_files.append((f"{ticker_safe}_analysis.xlsx", excel_bytes))
+                        
                     if word_bytes:
-                        col_btn2.download_button(
-                            label="📥 Download Word Report",
+                        dl_col2.download_button(
+                            label="📄 Download Word",
                             data=word_bytes,
-                            file_name=f"{ticker_safe}_Report_{timestamp_suffix}.docx",
-                            mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                            file_name=f"{ticker_safe}_report.docx",
+                            mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                            use_container_width=True
                         )
+                        download_files.append((f"{ticker_safe}_report.docx", word_bytes))
+                        
                     if pptx_bytes:
-                        col_btn3.download_button(
-                            label="📥 Download PowerPoint Deck",
+                        dl_col3.download_button(
+                            label="📊 Download PPTX",
                             data=pptx_bytes,
-                            file_name=f"{ticker_safe}_Presentation_{timestamp_suffix}.pptx",
-                            mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
+                            file_name=f"{ticker_safe}_deck.pptx",
+                            mime="application/vnd.openxmlformats-officedocument.presentationml.presentation",
+                            use_container_width=True
+                        )
+                        download_files.append((f"{ticker_safe}_deck.pptx", pptx_bytes))
+
+                    if len(download_files) > 1:
+                        import zipfile
+                        import io
+                        zip_buffer = io.BytesIO()
+                        with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
+                            for file_name, data in download_files:
+                                zip_file.writestr(file_name, data)
+                        dl_col4.download_button(
+                            label="📦 Download All (ZIP)",
+                            data=zip_buffer.getvalue(),
+                            file_name=f"{ticker_safe}_all_reports.zip",
+                            mime="application/zip",
+                            use_container_width=True
                         )
-                
                 # Write search activity log to audit table
                 selected_formats = [f for f, ok in [("xlsx", chk_excel), ("docx", chk_word), ("pptx", chk_pptx)] if ok]
                 save_audit_log(

web_app/requirements.txt

@@ -1,16 +1,18 @@
-streamlit>=1.30.0
-python-pptx>=0.6.21
-supabase==2.4.0
-requests>=2.31.0
-beautifulsoup4>=4.12.0
-lxml>=4.9.0
-python-dotenv>=1.0.0
-google-generativeai>=0.7.0
-google-genai>=0.8.0
-anthropic>=0.25.0
-openai>=1.0.0
-openpyxl>=3.1.0
-python-docx>=1.1.0
-pandas>=2.0.0
-Pillow>=10.0.0
-yfinance>=0.2.40
+streamlit
+python-pptx
+supabase
+requests
+beautifulsoup4
+lxml
+python-dotenv
+google-generativeai
+google-genai
+anthropic
+openai
+openpyxl
+python-docx
+pandas
+Pillow
+yfinance
+matplotlib
+seaborn