Upload folder using huggingface_hub

builders/build_excel.py

@@ -628,7 +628,6 @@ def build_workbook(data: dict, output_path: str) -> None:
     _growth_sheet(wb, data)
     _peers_sheet(wb, data)
     _swot_sheet(wb, data)
-    _narrative_sheet(wb, data)
     _sources_sheet(wb, data)
     wb.save(output_path)
 

pipeline/fetcher.py

@@ -1021,6 +1021,11 @@ def fetch_peer_snapshot(ticker: str) -> Optional[Dict]:
         key_stats    = t.key_stats.get(ticker, {})
         fin_data     = t.financial_data.get(ticker, {})
         summary_det  = t.summary_detail.get(ticker, {})
+        
+        # Handle yahooquery invalid crumb string returns
+        if isinstance(price_data, str) or isinstance(profile_data, str):
+            raise ValueError("yahooquery returned string instead of dict (Invalid Crumb)")
+            
         name = price_data.get("longName") or price_data.get("shortName", "")
         if not name: return None
         rev = None
@@ -1053,7 +1058,34 @@ def fetch_peer_snapshot(ticker: str) -> Optional[Dict]:
             "ev_ebitda": _s(key_stats.get("enterpriseToEbitda")),
         }
     except Exception:
-        return None
+        # Fallback to FMP if yahooquery fails and API key is present
+        try:
+            profile = (_fmp_get(f"/v3/profile/{ticker}") or [{}])[0]
+            name = profile.get("companyName")
+            if not name: return None
+            
+            rtm = (_fmp_get(f"/v3/ratios-ttm/{ticker}") or [{}])[0]
+            km = (_fmp_get(f"/v3/key-metrics-ttm/{ticker}") or [{}])[0]
+            
+            return {
+                "name": name, "ticker": ticker,
+                "rationale": f"Industry peer ({profile.get('industry', '')})",
+                "latest_year": "", "currency": profile.get("currency", "USD"),
+                "units": "actuals", "revenue": None,
+                "gross_margin": _s(rtm.get("grossProfitMarginTTM")),
+                "operating_margin": _s(rtm.get("operatingProfitMarginTTM")),
+                "net_margin": _s(rtm.get("netProfitMarginTTM")),
+                "roe": _s(rtm.get("returnOnEquityTTM")),
+                "roic": _s(rtm.get("returnOnCapitalEmployedTTM")),
+                "debt_to_equity": _s(rtm.get("debtEquityRatioTTM")),
+                "current_ratio": _s(rtm.get("currentRatioTTM")),
+                "fcf_margin": None,
+                "revenue_growth_3y_cagr": None,
+                "pe_ttm": _s(rtm.get("peRatioTTM")),
+                "ev_ebitda": _s(km.get("enterpriseValueOverEBITDATTM")),
+            }
+        except Exception:
+            return None
 
 
 def fetch_valuation(ticker: str) -> Dict:

pipeline/peer_selector.py

@@ -67,60 +67,161 @@ def _fmp_peers(ticker: str) -> List[str]:
     return []
 
 
-def _hf_intelligent_peers(meta: CompanyMeta, log_fn=None) -> List[str]:
-    """Use Hugging Face Serverless API to intelligently select granular peers."""
+def _parse_tickers_json(text: str) -> Optional[List[str]]:
+    """Parse JSON array of tickers from LLM response text."""
+    import re, json
+    # Match anything between [ and ] inclusive, across multiple lines
+    match = re.search(r'\[\s*(.*?)\s*\]', text, re.DOTALL)
+    if match:
+        arr_str = match.group(0)
+        try:
+            tickers = json.loads(arr_str)
+            if isinstance(tickers, list) and all(isinstance(t, str) for t in tickers):
+                return tickers
+        except Exception:
+            pass
+    return None
+
+
+def _llm_intelligent_peers(meta: CompanyMeta, log_fn=None) -> List[str]:
+    """Use the first available LLM API (Gemini, Claude, OpenAI, Groq, or Hugging Face) to select peers."""
     def log(msg):
         if log_fn: log_fn(msg)
-        
-    hf_key = getattr(config, "HF_API_KEY", "")
-    if not hf_key:
-        return []
-        
-    log("  -> Hugging Face API key detected. Using AI for granular sector breakdown and peer selection...")
+
     desc = meta.description if meta.description else "No description available."
-    try:
-        from huggingface_hub import InferenceClient
-        client = InferenceClient(api_key=hf_key)
-        
-        prompt = (
-            f"You are a top-tier financial analyst. Given the following company, break down its exact sub-sector "
-            f"and identify its 5 closest publicly traded peers.\n"
-            f"Company Name: {meta.name}\n"
-            f"Industry: {meta.industry}\n"
-            f"Description: {desc}\n\n"
-            f"Return ONLY a valid JSON array of their Yahoo Finance ticker symbols (e.g., [\"MSFT\", \"GOOGL\"]). "
-            f"Do not include any other text, markdown, or explanation. Only the JSON array."
-        )
-        
-        response = client.chat_completion(
-            model="meta-llama/Meta-Llama-3-8B-Instruct",
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=100,
-            temperature=0.1
-        )
-        
-        if response and response.choices:
-            text = response.choices[0].message.content
-            
-            # Extract JSON array using regex
-            import re, json
-            # Match anything between [ and ] inclusive, across multiple lines
-            match = re.search(r'\[\s*(.*?)\s*\]', text, re.DOTALL)
-            if match:
-                arr_str = match.group(0)
-                try:
-                    tickers = json.loads(arr_str)
-                    if isinstance(tickers, list) and all(isinstance(t, str) for t in tickers):
-                        log(f"  [OK] HF AI successfully identified highly specific peers: {tickers}")
-                        return tickers
-                except json.JSONDecodeError as e:
-                    log(f"  ⚠ HF AI JSON parse error: {e}")
-            log("  ⚠ HF AI returned invalid format, falling back...")
-        else:
-            log(f"  ⚠ HF API Error. Falling back...")
-    except Exception as e:
-        log(f"  ⚠ HF AI Request Failed: {e}. Falling back...")
-        
+    prompt = (
+        f"You are a top-tier financial analyst. Given the following company, break down its exact sub-sector "
+        f"and identify its 5 closest publicly traded peers.\n"
+        f"Company Name: {meta.name}\n"
+        f"Ticker: {meta.ticker}\n"
+        f"Industry: {meta.industry}\n"
+        f"Description: {desc}\n\n"
+        f"Return ONLY a valid JSON array of their Yahoo Finance ticker symbols (e.g., [\"MSFT\", \"GOOGL\"]). "
+        f"CRITICAL: The peers MUST be traded on the same exchange as the company. "
+        f"If the company's ticker has a suffix (e.g., .NS for India, .L for London), you MUST append the exact same suffix to all peer tickers.\n"
+        f"Do not include any other text, markdown, or explanation. Only the JSON array."
+    )
+
+    # 1. Try Gemini
+    gemini_key = getattr(config, "GEMINI_API_KEY", "")
+    if gemini_key:
+        log("  -> Gemini API key detected. Using Gemini for granular sector breakdown and peer selection...")
+        try:
+            gemini_model = getattr(config, "GEMINI_MODEL", "gemini-2.0-flash")
+            # Try new google-genai SDK
+            try:
+                from google import genai
+                from google.genai import types as gtypes
+                client = genai.Client(api_key=gemini_key)
+                response = client.models.generate_content(
+                    model=gemini_model,
+                    contents=prompt,
+                    config=gtypes.GenerateContentConfig(temperature=0.1, max_output_tokens=100),
+                )
+                tickers = _parse_tickers_json(response.text)
+                if tickers:
+                    log(f"  [OK] Gemini successfully identified peers: {tickers}")
+                    return tickers
+            except Exception:
+                pass
+
+            # Fallback to old SDK
+            import google.generativeai as genai_old
+            genai_old.configure(api_key=gemini_key)
+            model = genai_old.GenerativeModel(model_name=gemini_model)
+            response = model.generate_content(prompt)
+            tickers = _parse_tickers_json(response.text)
+            if tickers:
+                log(f"  [OK] Gemini (old SDK) successfully identified peers: {tickers}")
+                return tickers
+        except Exception as e:
+            log(f"  [Warning] Gemini peer selection failed: {e}")
+
+    # 2. Try Claude
+    claude_key = getattr(config, "CLAUDE_API_KEY", "")
+    if claude_key:
+        log("  -> Claude API key detected. Using Claude for granular sector breakdown and peer selection...")
+        try:
+            import anthropic
+            client = anthropic.Anthropic(api_key=claude_key)
+            claude_model = getattr(config, "CLAUDE_MODEL", "claude-3-5-haiku-20241022")
+            message = client.messages.create(
+                model=claude_model,
+                max_tokens=100,
+                temperature=0.1,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            tickers = _parse_tickers_json(message.content[0].text)
+            if tickers:
+                log(f"  [OK] Claude successfully identified peers: {tickers}")
+                return tickers
+        except Exception as e:
+            log(f"  [Warning] Claude peer selection failed: {e}")
+
+    # 3. Try OpenAI
+    openai_key = getattr(config, "OPENAI_API_KEY", "")
+    if openai_key:
+        log("  -> OpenAI API key detected. Using OpenAI for granular sector breakdown and peer selection...")
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=openai_key)
+            openai_model = getattr(config, "OPENAI_MODEL", "gpt-4o-mini")
+            resp = client.chat.completions.create(
+                model=openai_model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.1,
+                max_tokens=100,
+            )
+            tickers = _parse_tickers_json(resp.choices[0].message.content)
+            if tickers:
+                log(f"  [OK] OpenAI successfully identified peers: {tickers}")
+                return tickers
+        except Exception as e:
+            log(f"  [Warning] OpenAI peer selection failed: {e}")
+
+    # 4. Try Groq
+    groq_key = getattr(config, "GROQ_API_KEY", "")
+    if groq_key:
+        log("  -> Groq API key detected. Using Groq for granular sector breakdown and peer selection...")
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=groq_key, base_url="https://api.groq.com/openai/v1")
+            groq_model = getattr(config, "GROQ_MODEL", "llama-3.3-70b-versatile")
+            resp = client.chat.completions.create(
+                model=groq_model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.1,
+                max_tokens=100,
+            )
+            tickers = _parse_tickers_json(resp.choices[0].message.content)
+            if tickers:
+                log(f"  [OK] Groq successfully identified peers: {tickers}")
+                return tickers
+        except Exception as e:
+            log(f"  [Warning] Groq peer selection failed: {e}")
+
+    # 5. Try Hugging Face (Free-tier model Qwen/Qwen2.5-7B-Instruct)
+    hf_key = getattr(config, "HF_API_KEY", "")
+    if hf_key:
+        log("  -> Hugging Face API key detected. Using HF Qwen/Qwen2.5-7B-Instruct for peer selection...")
+        try:
+            from huggingface_hub import InferenceClient
+            client = InferenceClient(api_key=hf_key)
+            response = client.chat_completion(
+                model="Qwen/Qwen2.5-7B-Instruct",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=100,
+                temperature=0.1
+            )
+            if response and response.choices:
+                tickers = _parse_tickers_json(response.choices[0].message.content)
+                if tickers:
+                    log(f"  [OK] Hugging Face successfully identified peers: {tickers}")
+                    return tickers
+            log("  [Warning] Hugging Face response parsing failed.")
+        except Exception as e:
+            log(f"  [Warning] Hugging Face peer selection failed: {e}")
+
     return []
 
 
@@ -142,8 +243,8 @@ def select_peers(
 
     log(f"Selecting peers for {meta.name} ({meta.industry}) ...")
 
-    # 1. Try Hugging Face Intelligent Peers
-    peer_tickers = _hf_intelligent_peers(meta, log_fn)
+    # 1. Try LLM-based Intelligent Peers (Gemini, Claude, OpenAI, Groq, or HF)
+    peer_tickers = _llm_intelligent_peers(meta, log_fn)
 
     # 2. Try FMP peers endpoint if HF fails
     if not peer_tickers and FMP_API_KEY and meta.is_listed and ticker != "UNLISTED":
@@ -151,28 +252,43 @@ def select_peers(
         if peer_tickers:
             log(f"  -> FMP suggested {len(peer_tickers)} peers")
 
-    # 2. Fallback to hardcoded industry map
+    # 2. Fallback to hardcoded industry/sector map
     if not peer_tickers:
-        industry = meta.industry or meta.sector or ""
-        # Check Indian peers first
-        for key, tickers in INDIAN_PEERS.items():
-            if key.lower() in industry.lower() or industry.lower() in key.lower():
-                peer_tickers = [t for t in tickers if t.upper() != ticker.upper()][:max_peers]
-                log(f"  -> Using hardcoded Indian peers for '{key}'")
-                break
-        # Check global peers
-        if not peer_tickers:
-            for key, tickers in GLOBAL_PEERS.items():
+        industry = meta.industry or ""
+        # Try specific industry match first
+        if industry:
+            for key, tickers in INDIAN_PEERS.items():
                 if key.lower() in industry.lower() or industry.lower() in key.lower():
                     peer_tickers = [t for t in tickers if t.upper() != ticker.upper()][:max_peers]
-                    log(f"  -> Using hardcoded global peers for '{key}'")
+                    log(f"  -> Using hardcoded Indian peers for industry '{key}'")
                     break
+            if not peer_tickers:
+                for key, tickers in GLOBAL_PEERS.items():
+                    if key.lower() in industry.lower() or industry.lower() in key.lower():
+                        peer_tickers = [t for t in tickers if t.upper() != ticker.upper()][:max_peers]
+                        log(f"  -> Using hardcoded global peers for industry '{key}'")
+                        break
+        # Try general sector match if industry didn't match anything
+        if not peer_tickers:
+            sector = meta.sector or ""
+            if sector:
+                for key, tickers in INDIAN_PEERS.items():
+                    if key.lower() in sector.lower() or sector.lower() in key.lower():
+                        peer_tickers = [t for t in tickers if t.upper() != ticker.upper()][:max_peers]
+                        log(f"  -> Using hardcoded Indian peers for sector '{key}'")
+                        break
+                if not peer_tickers:
+                    for key, tickers in GLOBAL_PEERS.items():
+                        if key.lower() in sector.lower() or sector.lower() in key.lower():
+                            peer_tickers = [t for t in tickers if t.upper() != ticker.upper()][:max_peers]
+                            log(f"  -> Using hardcoded global peers for sector '{key}'")
+                            break
 
     # Remove self
     peer_tickers = [t for t in peer_tickers if t.upper() != ticker.upper()][:max_peers]
 
     if not peer_tickers:
-        log("  ⚠ No peers found. Peer comparison section will be skipped.")
+        log("  [Warning] No peers found. Peer comparison section will be skipped.")
         return []
 
     # 3. Fetch snapshots for each peer

pipeline/resolver.py

@@ -153,13 +153,16 @@ INDIAN_TICKERS = {
 def _guess_ticker(query: str) -> Optional[str]:
     """Try to find an Indian NSE ticker for a given name/query."""
     q = query.lower().strip()
+    
+    # Clean up standard suffixes for safer matching
+    clean_q = q.replace(".ns", "").replace(".bo", "").replace(" ltd", "").replace(" limited", "").strip()
+
     # Exact match
+    if clean_q in INDIAN_TICKERS:
+        return INDIAN_TICKERS[clean_q]
     if q in INDIAN_TICKERS:
         return INDIAN_TICKERS[q]
-    # Partial match
-    for key, ticker in INDIAN_TICKERS.items():
-        if key in q or q in key:
-            return ticker
+        
     return None
 
 

supabase_webhook_guide.md

@@ -0,0 +1,152 @@
+# 🔌 Supabase Audit Webhook Integration Guide
+
+This guide explains how to configure Supabase Database Webhooks to send real-time alerts (e.g., to Slack, MS Teams, or Discord) whenever a user performs a financial statement analysis and a new entry is added to the `financial_analysis_audit` table.
+
+---
+
+## 1. Supabase Dashboard Configuration
+
+Follow these steps to enable the database webhook directly in the Supabase Dashboard:
+
+1. **Navigate to Database Webhooks**:
+   - Go to your [Supabase Project Dashboard](https://supabase.com/dashboard).
+   - Select your project, click on **Database** in the left sidebar, and click on **Webhooks** (or go to **Integrations** -> **Webhooks**).
+   - Click the **Enable Webhooks** button if webhooks are not already enabled.
+
+2. **Create Webhook**:
+   - Click **Create Webhook**.
+   - **Name**: `send_audit_notification`
+   - **Schema**: `public`
+   - **Table**: `financial_analysis_audit`
+   - **Events**: Toggle on **`INSERT`** only (so it fires only when a new log is created).
+   - **Webhook Type**: Select **HTTP POST**.
+   - **HTTP URL**: 
+     - If routing via **Zapier/Make**, enter your webhook trigger URL.
+     - If routing directly to Slack, enter your **Supabase Edge Function URL** (see Section 3 for direct Slack formatting).
+   - **Timeout**: `10` seconds (default).
+   - Click **Create Webhook**.
+
+---
+
+## 2. Event Payload Schema
+
+When a new row is inserted, Supabase POSTs a JSON payload with the following schema:
+
+```json
+{
+  "type": "INSERT",
+  "table": "financial_analysis_audit",
+  "schema": "public",
+  "record": {
+    "id": 42,
+    "timestamp": "2026-05-22T10:09:00Z",
+    "user_email": "analyst@company.com",
+    "company_ticker": "TCS.NS",
+    "company_name": "Tata Consultancy Services Limited",
+    "selected_formats": "xlsx, docx, pptx",
+    "ai_model_used": "groq, gemini",
+    "status": "completed"
+  },
+  "old_record": null
+}
+```
+
+---
+
+## 3. Formatting for Slack / Teams (Supabase Edge Function)
+
+Since Slack and Teams require specific JSON formats (e.g., `{"text": "..."}`), you cannot point the Supabase Database Webhook directly to Slack's webhook URL without a translator. 
+
+Below is the code for a lightweight **Supabase Edge Function** in TypeScript that acts as a translator.
+
+### Edge Function Code (`index.ts`)
+```typescript
+import { serve } from "https://deno.land/std@0.168.0/http/server.ts"
+
+const SLACK_WEBHOOK_URL = Deno.env.get("SLACK_WEBHOOK_URL") || "";
+
+serve(async (req) => {
+  try {
+    const payload = await req.json();
+    const record = payload.record;
+
+    if (!record) {
+      return new Response(JSON.stringify({ error: "No record found" }), { status: 400 });
+    }
+
+    // Build a rich Slack block layout
+    const slackMessage = {
+      text: `📈 New Financial Analysis Run: ${record.company_name} (${record.company_ticker})`,
+      blocks: [
+        {
+          type: "header",
+          text: {
+            type: "plain_text",
+            text: "📈 Financial Statement Analysis Logged",
+            emoji: true
+          }
+        },
+        {
+          type: "section",
+          fields: [
+            {
+              type: "mrkdwn",
+              text: `*User:* \`${record.user_email}\``
+            },
+            {
+              type: "mrkdwn",
+              text: `*Company:* *${record.company_name}* (\`${record.company_ticker}\`)`
+            },
+            {
+              type: "mrkdwn",
+              text: `*Formats Generated:* \`${record.selected_formats}\``
+            },
+            {
+              type: "mrkdwn",
+              text: `*AI Engines Used:* \`${record.ai_model_used}\``
+            }
+          ]
+        },
+        {
+          type: "context",
+          elements: [
+            {
+              type: "mrkdwn",
+              text: `*Status:* ${record.status === "completed" ? "✅ Completed Successfully" : "❌ Failed"}  |  *Time:* \`${record.timestamp}\``
+            }
+          ]
+        }
+      ]
+    };
+
+    // Forward formatted payload to Slack
+    const response = await fetch(SLACK_WEBHOOK_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(slackMessage),
+    });
+
+    return new Response(JSON.stringify({ success: true }), { status: 200 });
+
+  } catch (error) {
+    return new Response(JSON.stringify({ error: error.message }), { status: 500 });
+  }
+})
+```
+
+### Steps to Deploy the Edge Function:
+1. Install Supabase CLI: `npm install -g supabase`
+2. Login: `supabase login`
+3. Initialize in your folder: `supabase init`
+4. Create Edge Function: `supabase functions new slack-notifier`
+5. Replace the generated code in `supabase/functions/slack-notifier/index.ts` with the TypeScript code above.
+6. Set the Slack Webhook secret:
+   ```bash
+   supabase secrets set SLACK_WEBHOOK_URL=https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
+   ```
+7. Deploy the function:
+   ```bash
+   supabase functions deploy slack-notifier --project-ref your-project-ref-id
+   ```
+8. Set the Webhook URL in Supabase Dashboard to point to your new deployed function:
+   `https://your-project-ref-id.supabase.co/functions/v1/slack-notifier`