Cleaned files

app.py

@@ -1,5 +1,6 @@
 import gradio as gr
 import os
+
 print("APP STARTED", flush=True)
 
 from app.db.repo import init_db
@@ -9,9 +10,11 @@ from app.controller.session_loader import load_google_ads_data
 from app.ads1.ads_analyst import run_ads_analyst_card
 from app.ads1.budget_optimizer import run_budget_optimizer_card
 import spaces
+
 print("🔥 STEP 1: imports done", flush=True)
 
-# @spaces.GPU(duration=0)
+
+@spaces.GPU(duration=120)
 def run_ads_card(state):
     print("\n🔥 [run_ads_card] ENTERED", flush=True)
     try:
@@ -23,6 +26,9 @@ def run_ads_card(state):
         dfs = state.get("full_dfs")
         print("📊 [run_ads_card] extracted dfs:", type(dfs), flush=True)
 
+        if not dfs:
+            return "⚠️ No campaign data — select a campaign on the Dashboard tab first."
+
         result = run_ads_analyst_card(dfs)
         print("✅ [run_ads_card] returning result", flush=True)
         return result
@@ -30,19 +36,26 @@ def run_ads_card(state):
         print("❌ [run_ads_card] ERROR:", repr(e), flush=True)
         return f"⚠️ Analysis failed: {e}"
 
-# def run_ads_card(state):
-#     print("🔥 FUNCTION CALLED", flush=True)
-#     return "test"
-    
-# def run_ads_card(state):
-#     if not state:
-#         return "⚠️ Select a campaign from the Dashboard tab first."
-#     return run_ads_analyst_card(state["full_dfs"])
 
+@spaces.GPU(duration=120)
 def run_budget_card(state):
-    if not state:
-        return "⚠️ Select a campaign from the Dashboard tab first."
-    return run_budget_optimizer_card(state["full_dfs"])
+    print("\n🔥 [run_budget_card] ENTERED", flush=True)
+    try:
+        if not state:
+            print("❌ [run_budget_card] state is EMPTY", flush=True)
+            return "⚠️ Select a campaign first"
+
+        dfs = state.get("full_dfs")
+        if not dfs:
+            return "⚠️ No campaign data — select a campaign on the Dashboard tab first."
+
+        result = run_budget_optimizer_card(dfs)
+        print("✅ [run_budget_card] returning result", flush=True)
+        return result
+    except Exception as e:
+        print("❌ [run_budget_card] ERROR:", repr(e), flush=True)
+        return f"⚠️ Budget optimization failed: {e}"
+
 
 def startup():
     try:
@@ -53,6 +66,7 @@ def startup():
         print("⚠️ DB failed:", e, flush=True)
         return "error"
 
+
 print("🔥 STEP 2: DB init done", flush=True)
 
 # UI Optimization: Fetch data AFTER UI elements are drawn
@@ -63,13 +77,6 @@ def initial_data_load():
     spend, leads, cpl, count, formatted_df = get_dashboard_data()
     return dfs, formatted_df, spend, leads, cpl, count
 
-# def campaign_row_selected(evt: gr.SelectData, df, full_state):
-#     if df.empty or full_state is None:
-#         return gr.State(), "⚠️ Data state is missing. Please click Refresh."
-#     row_index = evt.index[0]
-#     campaign_name = df.iloc[row_index]["Campaign"]
-#     campaign_state = on_campaign_select(full_state, campaign_name)
-#     return campaign_state, f"## 📊 Selected Campaign: {campaign_name}"
 
 def campaign_row_selected(df, full_state, evt: gr.SelectData):
     row_index = evt.index[0]
@@ -77,6 +84,7 @@ def campaign_row_selected(df, full_state, evt: gr.SelectData):
     campaign_state = on_campaign_select(full_state, campaign_name)
     return campaign_state, f"## 📊 Selected Campaign: {campaign_name}"
 
+
 print("🔥 STEP 3: building UI", flush=True)
 
 with gr.Blocks() as demo:
@@ -102,38 +110,31 @@ with gr.Blocks() as demo:
     with gr.Tab("Analysis"):
         selected = gr.Markdown("👈 Select a campaign from the Dashboard tab")
         output = gr.Markdown()
-        
+
         with gr.Row():
             gr.Button("🚀 Run Ads Analysis").click(run_ads_card, campaign_state, output)
             gr.Button("💰 Run Budget Optimization").click(run_budget_card, campaign_state, output)
 
-    # Core Event Bindings
-    # campaign_table.change(fn=lambda x: x, inputs=[campaign_table], outputs=df_state)
-    # campaign_table.select(
-    #     fn=campaign_row_selected,
-    #     inputs=[df_state, full_state],
-    #     outputs=[campaign_state, selected]
-    # )
-
     campaign_table.select(
         fn=campaign_row_selected,
         inputs=[campaign_table, full_state],
-        outputs=[campaign_state, selected]
+        outputs=[campaign_state, selected],
     )
 
     # Button manual refresh
     refresh_btn.click(
         fn=initial_data_load,
-        outputs=[full_state, campaign_table, total_spend, total_leads, average_cpl, active_campaigns]
+        outputs=[full_state, campaign_table, total_spend, total_leads, average_cpl, active_campaigns],
     )
 
     # ⚡ MAGIC FIX: App automatically loads data into UI components instantly on launch
     demo.load(
         fn=initial_data_load,
-        outputs=[full_state, campaign_table, total_spend, total_leads, average_cpl, active_campaigns]
+        outputs=[full_state, campaign_table, total_spend, total_leads, average_cpl, active_campaigns],
     )
     demo.load(fn=startup, outputs=[])
 
 demo.queue()
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

app/ads1/ads_analyst.py

@@ -9,6 +9,7 @@ TARGET_CPL = 20.0
 # 1. DATA BUILDERS
 # -------------------------
 
+
 def build_campaign_snapshot(dfs: dict) -> dict:
     df = dfs["campaigns"]
 
@@ -86,6 +87,7 @@ def build_signals(dfs: dict) -> dict:
 # 2. CONTEXT BUILDER
 # -------------------------
 
+
 def build_ads_analyst_context(dfs: dict) -> dict:
     return {
         "campaign": build_campaign_snapshot(dfs),
@@ -99,6 +101,7 @@ def build_ads_analyst_context(dfs: dict) -> dict:
 # 3. PROMPT BUILDER
 # -------------------------
 
+
 def build_ads_analyst_prompt(context: dict) -> str:
     return f"""
 You are an Ads performance analyst.
@@ -125,38 +128,19 @@ Format:
 """
 
 
-# -------------------------
-# 4. MAIN ORCHESTRATOR (THIS IS WHAT MAIN.PY CALLS)
-# -------------------------
-
-# def run_ads_analyst_card(dfs: dict) -> str:
-#     context = build_ads_analyst_context(dfs)
-#     prompt = build_ads_analyst_prompt(context)
-
-#     print("\n========== PROMPT ==========")
-#     print(prompt)
-
-#     result = generate_explanation(prompt)
-
-#     print("\n========== LLM OUTPUT ==========")
-#     print(result)
-
-#     return result
-
 def run_ads_analyst_card(dfs: dict) -> str:
     print("\n🚀 [analyst_card] STARTED", flush=True)
 
+    if not dfs:
+        return "⚠️ No campaign data — select a campaign on the Dashboard tab first."
+
     context = build_ads_analyst_context(dfs)
     print("🧠 [analyst_card] context built", flush=True)
 
     prompt = build_ads_analyst_prompt(context)
     print("✍️ [analyst_card] prompt built", flush=True)
 
-    print("\n========== PROMPT ==========")
-    print(prompt)
-
     result = generate_explanation(prompt)
-
     print("\n📤 [analyst_card] LLM result received", flush=True)
 
-    return result
+    return result

app/models/llm.py

@@ -1,35 +1,72 @@
+from __future__ import annotations
+
 import os
+import threading
+
 from huggingface_hub import hf_hub_download
 from llama_cpp import Llama
 
-_model = None
+HF_REPO = "Abiray/MiniCPM5-1B-GGUF"
+HF_FILENAME = "minicpm5-1b-Q4_K_M.gguf"
 
-def load_model():
-    print("🧠 [load_model] called", flush=True)
+_model: Llama | None = None
+_init_lock = threading.Lock()
+
+
+def _preload_cuda_libs() -> None:
+    try:
+        import ctypes
+
+        import nvidia.cublas
+        import nvidia.cuda_runtime
+    except ImportError:
+        return
+
+    for module, lib_name in (
+        (nvidia.cublas, "libcublas.so.12"),
+        (nvidia.cuda_runtime, "libcudart.so.12"),
+    ):
+        lib_path = os.path.join(module.__path__[0], "lib", lib_name)
+        if os.path.isfile(lib_path):
+            ctypes.CDLL(lib_path, mode=ctypes.RTLD_GLOBAL)
+
+
+def load_model() -> Llama:
     global _model
+    print("🧠 [load_model] called", flush=True)
 
     if _model is not None:
         print("🧠 [load_model] returning cached model", flush=True)
         return _model
 
-    print("⬇️ [load_model] downloading model...", flush=True)
-    model_path = hf_hub_download(
-        repo_id="Abiray/MiniCPM5-1B-GGUF",
-        filename="minicpm5-1b-Q4_K_M.gguf",
-    )
-
-    print(f"✅ [load_model] model downloaded at {model_path}", flush=True)
+    with _init_lock:
+        if _model is not None:
+            return _model
 
-    gpu_layers = int(os.getenv("LLAMA_GPU_LAYERS", "0"))
-    print(f"🚀 [load_model] initializing Llama with n_gpu_layers={gpu_layers}", flush=True)
+        print("⬇️ [load_model] downloading model...", flush=True)
+        model_path = hf_hub_download(
+            repo_id=HF_REPO,
+            filename=HF_FILENAME,
+        )
+        print(f"✅ [load_model] model downloaded at {model_path}", flush=True)
 
-    _model = Llama(
-        model_path=model_path,
-        n_ctx=4096,
-        n_gpu_layers=gpu_layers,
-        verbose=True,
-    )
+        _preload_cuda_libs()
+        gpu_layers = int(os.getenv("LLAMA_GPU_LAYERS", "-1"))
+        n_ctx = int(os.getenv("LLAMA_N_CTX", "2048"))
+        n_threads = int(os.getenv("LLAMA_N_THREADS", "4"))
+        print(
+            f"🚀 [load_model] initializing Llama "
+            f"(n_gpu_layers={gpu_layers}, n_ctx={n_ctx}, n_threads={n_threads})",
+            flush=True,
+        )
 
-    print("✅ [load_model] model initialized", flush=True)
+        _model = Llama(
+            model_path=model_path,
+            n_ctx=n_ctx,
+            n_gpu_layers=gpu_layers,
+            n_threads=n_threads,
+            verbose=False,
+        )
+        print("✅ [load_model] model initialized", flush=True)
 
-    return _model
+    return _model

app/recs/generate.py

@@ -1,84 +1,100 @@
-from typing import Dict, Iterator
+from __future__ import annotations
+
+import os
 import re
-import spaces
+import traceback
+from typing import Dict
+
 from app.models.llm import load_model
 
 TARGET_CPL = 20.0
 
+_IM_END = "<|im_end|>"
+_STOP_SEQUENCES = [_IM_END, "<|im_start|>", "</s>"]
+
 
-def fallback_explanation(rec: Dict = None) -> str:
+def fallback_explanation(rec: Dict | None = None) -> str:
     return "This recommendation was generated from campaign performance metrics."
 
 
-def sanitize_explanation(text: str, rec: Dict = None) -> str:
+def sanitize_explanation(text: str, rec: Dict | None = None) -> str:
     cleaned = re.sub(r"\s+", " ", text).strip()
-
     if not cleaned or len(cleaned) < 10:
         return fallback_explanation(rec)
-
     return cleaned
 
-@spaces.GPU(duration=120)
-def generate_explanation(prompt: str, rec: Dict = None, stream: bool = False):
+
+def _messages_to_prompt(messages: list[dict[str, str]]) -> str:
+    chunks: list[str] = []
+    for msg in messages:
+        role = msg["role"]
+        content = msg["content"]
+        if role == "system":
+            chunks.append(f"<|im_start|>system\n{content}\n")
+        elif role == "user":
+            chunks.append(f"<|im_start|>user\n{content}\n")
+        elif role == "assistant":
+            chunks.append(f"<|im_start|>assistant\n{content}\n")
+    chunks.append("<|im_start|>assistant\n")
+    return "".join(chunks)
+
+
+def generate_explanation(prompt: str, rec: Dict | None = None, stream: bool = False) -> str:
     print("\n🔥 [generate_explanation] CALLED", flush=True)
 
     try:
-        print(f"🧾 [generate_explanation] prompt type={type(prompt).__name__} len={len(str(prompt))}", flush=True)
+        print(
+            f"🧾 [generate_explanation] prompt type={type(prompt).__name__} "
+            f"len={len(str(prompt))}",
+            flush=True,
+        )
 
         llm = load_model()
         print("🧠 [generate_explanation] model loaded", flush=True)
 
-        print("🚀 [generate_explanation] calling LLM...", flush=True)
+        user_content = str(prompt).rstrip()
+        if "/no_think" not in user_content:
+            user_content = f"{user_content} /no_think"
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are an expert marketing analyst. Output only the final answer.",
+            },
+            {"role": "user", "content": user_content},
+        ]
 
-        response = llm.create_chat_completion(
-            messages=[
-                {
-                    "role": "system",
-                    "content": "You are an expert marketing analyst. Output only final answer."
-                },
-                {"role": "user", "content": prompt}
-            ],
+        print("🚀 [generate_explanation] calling LLM...", flush=True)
+        out = llm(
+            _messages_to_prompt(messages),
+            max_tokens=int(os.getenv("LLAMA_MAX_TOKENS", "512")),
             temperature=0.7,
+            stop=_STOP_SEQUENCES,
+            echo=False,
         )
-
+        raw = (out["choices"][0].get("text") or "").strip()
         print("📡 [generate_explanation] response received", flush=True)
-
-        raw = response["choices"][0]["message"]["content"]
-
         print("📄 [generate_explanation] raw output length:", len(raw), flush=True)
 
-        clean = re.sub(r"<think>.*?</think>", "", raw, flags=re.DOTALL)
+        clean = re.sub(
+            r"<\s*think\s*>.*?<\s*/\s*think\s*>",
+            "",
+            raw,
+            flags=re.DOTALL | re.IGNORECASE,
+        )
+        clean = re.sub(
+            r"<think>.*?</think>",
+            "",
+            clean,
+            flags=re.DOTALL | re.IGNORECASE,
+        )
+        clean = re.sub(r"\s+", " ", clean).strip()
+        clean = sanitize_explanation(clean, rec)
 
         print("✨ [generate_explanation] cleaned output ready", flush=True)
-
         return clean
 
     except Exception as e:
-        print("❌ [generate_explanation] ERROR:", e, flush=True)
+        print("❌ [generate_explanation] ERROR:", repr(e), flush=True)
+        traceback.print_exc()
         return fallback_explanation(rec)
-    
-# def generate_explanation(prompt: str, rec: Dict = None, stream: bool = False):
-#     print("🔥 LLM CALLED")
-
-#     llm = load_model()
-
-#     try:
-
-#         response = llm.create_chat_completion(
-#         messages=[
-#             {"role": "system", "content": "You are an expert marketing analyst for Google Ads.You MUST NOT output reasoning, thinking, or tags like <think>.You MUST ONLY output final answer."},
-#             {"role": "user", "content": prompt}
-#         ],
-#         temperature=0.7,)
-#         raw = response["choices"][0]["message"]["content"]
-
-#         clean = re.sub(r"<think>.*?</think>", "", raw, flags=re.DOTALL)
-#         clean = re.sub(r"(?s).*?Reasoning:.*?\n", "", clean)
-#         clean = re.sub(r"(?s).*?Step \d+.*?\n", "", clean)
-
-#         print(clean)
-#         return clean
-
-#     except Exception as e:
-#         print("❌ LLM ERROR:", e)
-#         return fallback_explanation(rec)