Budget optimizer card added

app.py

@@ -13,6 +13,7 @@ from app.ads1.ads_analyst import run_ads_analyst_card
 print("IMPORT 4 OK", flush=True)
 from app.ads1.search_term_optimizer import run_search_term_optimizer
 from app.ads1.keyword_inspector import run_keyword_inspector
+from app.ads1.budget_optimizer import run_budget_optimizer
 
 # ==================================================
 # ROMER / ADVISOR DASHBOARD THEME
@@ -555,6 +556,11 @@ button.ads-analyst-card::before {
     content: "Campaign insights.";
 }
 
+.budget-optimizer-card button::before,
+button.budget-optimizer-card::before {
+    content: "Where to adjust spend?";
+}
+
 .keyword-inspector-card button::before,
 button.keyword-inspector-card::before {
     content: "Winning versus wasting keywords.";
@@ -1025,6 +1031,23 @@ def run_ads_card(state):
     except Exception as e:
         return f"Analysis failed: {e}"
     
+@spaces.GPU(duration=120)
+def run_budget_card(state):
+    try:
+        if not state:
+            return "Select a campaign first."
+
+        dfs = state.get("full_dfs")
+        campaign_name = state.get("campaign_name")
+
+        if dfs is None or campaign_name is None:
+            return "Campaign state is not properly initialized."
+
+        return run_budget_optimizer(dfs, campaign_name=campaign_name)
+
+    except Exception as e:
+        return f"Analysis failed: {e}"
+    
 @spaces.GPU(duration=120)
 def run_search_term_optimizer_card(state):
     try:
@@ -1100,7 +1123,10 @@ with gr.Blocks(fill_height=True, fill_width=True, css=CSS) as demo:
                         value="Ads Analyst",
                         elem_classes=["ai-button-card", "ads-analyst-card"],
                     )
-                    gr.HTML(ai_card("Budget Optimizer", "Where to adjust spend?"))
+                    budget_optimizer_card = gr.Button(
+                        value="Budget Optimizer",
+                        elem_classes=["ai-button-card", "budget-optimizer-card"],
+                    )
                     keyword_inspector_card = gr.Button(
                         value="Keyword Inspector",
                         elem_classes=["ai-button-card", "keyword-inspector-card"],
@@ -1134,6 +1160,12 @@ with gr.Blocks(fill_height=True, fill_width=True, css=CSS) as demo:
         outputs=ads_output,
     )
 
+    budget_optimizer_card.click(
+        fn=run_ads_card,
+        inputs=campaign_state,
+        outputs=ads_output,
+    )
+
     search_term_cleaner_card.click(
         fn=run_search_term_optimizer_card,
         inputs=campaign_state,

app/ads1/budget_optimizer.py

@@ -1,113 +1,105 @@
 import json
-
+import pandas as pd
 from app.recs.generate import generate_explanation, is_bad_llm_output
 
+def build_budget_features(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
 
-def build_campaign_summary(dfs: dict) -> dict:
-    df = dfs["keywords"]
+    df["cost"] = df["cost"].fillna(0)
+    df["clicks"] = df["clicks"].fillna(0)
+    df["impressions"] = df["impressions"].fillna(0)
+    df["conversions"] = df.get("conversions", 0).fillna(0)
 
-    total_cost = df["cost"].sum()
-    total_conv = df["conversions"].sum()
+    # Core efficiency signals
+    df["ctr"] = (df["clicks"] / df["impressions"].replace(0, 1)) * 100
+    df["cpa"] = df["cost"] / df["conversions"].replace(0, 1)
+    df["cpc"] = df["cost"] / df["clicks"].replace(0, 1)
 
-    avg_cpl = total_cost / total_conv if total_conv > 0 else 0
+    # Budget efficiency proxy (VERY important for reasoning)
+    df["conv_per_cost"] = df["conversions"] / df["cost"].replace(0, 1)
 
-    return {
-        "total_spend": round(float(total_cost), 2),
-        "total_conversions": int(total_conv),
-        "avg_cpl": round(float(avg_cpl), 2),
-    }
+    return df
 
+def build_budget_optimizer_context(dfs: dict, campaign_name: str | None = None):
+    df = dfs["campaigns"].copy()
 
-def build_scale_candidates(dfs: dict):
-    kw = dfs["keywords"].copy()
-    if kw.empty:
-        return []
+    if campaign_name and "name" in df.columns:
+        df = df[df["name"] == campaign_name]
 
-    kw["cpl"] = kw["cost"] / kw["conversions"].replace(0, 1)
+    df = build_budget_features(df)
 
-    account_avg = kw["cost"].sum() / max(kw["conversions"].sum(), 1)
+    # Keep top variance slice (NOT rule-based, just signal control)
+    df = df.sort_values("cost", ascending=False).head(200)
 
-    winners = kw[(kw["conversions"] > 0) & (kw["cpl"] < account_avg * 0.7)]
-    winners = winners.sort_values("conversions", ascending=False)
+    return {
+        "campaign_name": campaign_name,
+        "campaigns": df.to_dict("records")
+    }
 
-    return winners.head(3)[["keyword", "ad_group_name", "cpl", "conversions"]].to_dict("records")
+def build_budget_optimizer_prompt(context: dict) -> str:
+    payload = json.dumps(context, indent=2, default=str)
+    name = context.get("campaign_name", "this account")
 
+    return f"""
+        You are a senior Google Ads budget optimization strategist.
 
-def build_cut_candidates(dfs: dict):
-    kw = dfs["keywords"].copy()
-    if kw.empty:
-        return []
+        Your job is to identify how to reallocate budget to improve overall performance.
 
-    kw["cpl"] = kw["cost"] / kw["conversions"].replace(0, 1)
+        Campaign scope: {name}
 
-    account_avg = kw["cost"].sum() / max(kw["conversions"].sum(), 1)
+        You must analyze the data and decide:
 
-    losers = kw[(kw["cost"] > 0) & ((kw["conversions"] == 0) | (kw["cpl"] > account_avg * 1.5))]
-    losers = losers.sort_values("cost", ascending=False)
+        - Where money is being wasted
+        - Which campaigns deserve MORE budget
+        - Which campaigns should be reduced or paused
+        - Any inefficient spend patterns
+        - Any hidden high-efficiency opportunities
 
-    return losers.head(3)[["keyword", "ad_group_name", "cost", "conversions", "cpl"]].to_dict("records")
+        IMPORTANT:
+        - Do NOT rely on hard thresholds
+        - Do NOT assume rules like "CPA > X = bad"
+        - Think in relative performance vs distribution
+        - Focus on efficiency vs cost imbalance
 
+        OUTPUT FORMAT:
+        Return 3 to 5 bullet points.
 
-def _dfs_for_campaign(dfs: dict, campaign_name: str | None) -> dict:
-    if not campaign_name:
-        return dfs
-    out = dict(dfs)
-    if "keywords" in dfs and "campaign_name" in dfs["keywords"].columns:
-        out["keywords"] = dfs["keywords"][dfs["keywords"]["campaign_name"] == campaign_name]
-    return out
+        Each bullet must:
+        - start with "- "
+        - include a clear recommendation
+        - include reasoning based on metrics
 
+        Example style:
+        - "Shift budget from X to Y because..."
+        - "Reduce spend on Z due to..."
+        - "Increase allocation to A since..."
 
-def build_budget_optimizer_context(dfs: dict, campaign_name: str | None = None) -> dict:
-    ctx = {
-        "summary": build_campaign_summary(dfs),
-        "scale_candidates": build_scale_candidates(dfs),
-        "cut_candidates": build_cut_candidates(dfs),
-    }
-    if campaign_name:
-        ctx["campaign_name"] = campaign_name
-    return ctx
+        DATA:
+        {payload}
+        """
 
+def run_budget_optimizer(dfs: dict, campaign_name: str | None = None) -> str:
+    print("\n🚀 [budget_optimizer] STARTED", flush=True)
+
+    if not dfs or "campaigns" not in dfs:
+        return "⚠️ No campaign data available."
+
+    context = build_budget_optimizer_context(dfs, campaign_name)
+
+    print("🧠 [budget_optimizer] context built", flush=True)
 
-def build_budget_optimizer_prompt(context: dict) -> str:
-    payload = json.dumps(context, indent=2, default=str)
-    name = context.get("campaign_name", "this campaign")
-    return (
-        f"Write 3 to 5 bullet points on where to increase or cut budget for {name}.\n"
-        "Use simple business language. Start each line with '- '. No intro sentence.\n\n"
-        f"Data (JSON):\n{payload}"
-    )
-
-
-def rule_based_budget(context: dict) -> str:
-    bullets: list[str] = []
-    for row in context.get("scale_candidates", [])[:2]:
-        bullets.append(
-            f"- Increase budget on '{row['keyword']}' — {row['conversions']} conversions at CPL ${row['cpl']:.2f}."
-        )
-    for row in context.get("cut_candidates", [])[:2]:
-        if row.get("conversions", 0) == 0:
-            bullets.append(f"- Cut spend on '{row['keyword']}' — ${row['cost']:.2f} spent with no conversions.")
-        else:
-            bullets.append(f"- Reduce budget on '{row['keyword']}' — CPL ${row['cpl']:.2f} is above average.")
-    if not bullets:
-        bullets.append("- Review keyword-level spend and shift budget toward terms with the lowest CPL.")
-    return "\n\n".join(bullets[:5])
-
-
-def run_budget_optimizer_card(dfs, campaign_name: str | None = None):
-    scoped = _dfs_for_campaign(dfs, campaign_name)
-    context = build_budget_optimizer_context(scoped, campaign_name)
     prompt = build_budget_optimizer_prompt(context)
 
-    rec = {
-        "campaign_id": "BUDGET_OPTIMIZER",
-        "type": "budget_optimization",
-        "action": "reallocate_budget",
-        "reason": prompt,
-    }
+    print("✍️ [budget_optimizer] prompt built", flush=True)
+
+    result = generate_explanation(prompt)
 
-    result = generate_explanation(prompt, rec=rec)
     if is_bad_llm_output(result):
-        print("⚠️ [budget_optimizer] LLM fallback — using rule-based budget tips", flush=True)
-        result = rule_based_budget(context)
-    return result
+        print("⚠️ [budget_optimizer] fallback triggered", flush=True)
+        return (
+            "- Unable to generate budget recommendations right now.\n"
+            "- Try again or check campaign data quality."
+        )
+
+    print("📤 [budget_optimizer] result received", flush=True)
+    return result