Update app.py

app.py

@@ -3,10 +3,9 @@ import time
 import requests
 import json
 import pandas as pd
-import plotly.graph_objects as go
+import gradio as gr
 import plotly.express as px
 from datetime import date, timedelta
-from nicegui import ui, app, run
 
 # =====================================================
 # CONFIG / SECRETS
@@ -15,14 +14,11 @@ API_TOKEN = os.getenv("LEADFEEDER_API_TOKEN")
 APP_PASSWORD = os.getenv("APP_PASSWORD")
 
 if not API_TOKEN or not APP_PASSWORD:
-    # Fallback for testing if env vars aren't set
-    print("⚠️ WARNING: Env vars not set. Using placeholders for code structure.")
-    API_TOKEN = "PLACEHOLDER_TOKEN"
-    APP_PASSWORD = "password123" 
+    raise RuntimeError("Missing required secrets: LEADFEEDER_API_TOKEN or APP_PASSWORD")
 
-ACCOUNT_ID = "255333"
+ACCOUNT_ID = "255333"  # PREMIUM account
 BASE_URL = "https://api.leadfeeder.com"
-PAGE_SIZE = 50 
+PAGE_SIZE = 100 
 
 HEADERS = {
     "Authorization": f"Token token={API_TOKEN}",
@@ -30,7 +26,7 @@ HEADERS = {
 }
 
 # =====================================================
-# LOGIC & PRESETS (Pure Python Functions)
+# PRESETS
 # =====================================================
 DASHBOARD_PRESETS = {
     "Total Visits by Industry": ("primary_industry", "total_visits", "sum"),
@@ -52,11 +48,15 @@ TREND_PRESETS = {
     "Visits Trend by Assignee": ("total_visits", "sum", "assignee"),
 }
 
+# =====================================================
+# UTILS: RATE LIMIT HANDLER
+# =====================================================
 def make_request(url, params=None):
     retries = 3
     while retries > 0:
         r = requests.get(url, headers=HEADERS, params=params, timeout=45)
         if r.status_code == 429:
+            print("⏳ Rate limit hit. Sleeping for 60 seconds...")
             time.sleep(61)
             retries -= 1
             continue
@@ -64,18 +64,32 @@ def make_request(url, params=None):
         return r.json()
     raise Exception("Max retries exceeded")
 
+# =====================================================
+# DATA FETCHING
+# =====================================================
 def fetch_basic_leads(start_date, end_date):
+    """ Step 1: Fetch ALL company details (fast fetch). """
     page = 1
     rows = []
+    
+    print(f"🚀 Fetching full company list for {start_date} to {end_date}...")
+    
     while True:
         try:
             js = make_request(
                 f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads",
-                params={"start_date": start_date, "end_date": end_date, "page[number]": page, "page[size]": PAGE_SIZE, "include": "location"}
+                params={
+                    "start_date": start_date,
+                    "end_date": end_date,
+                    "page[number]": page,
+                    "page[size]": PAGE_SIZE,
+                    "include": "location" 
+                }
             )
             data = js.get("data", [])
-            if not data: break
-            
+            if not data:
+                break
+                
             included = js.get("included", [])
             loc_map = {str(i["id"]): i["attributes"] for i in included if i["type"] == "locations"}
             
@@ -83,400 +97,290 @@ def fetch_basic_leads(start_date, end_date):
                 a = lead["attributes"]
                 loc_id = lead.get("relationships", {}).get("location", {}).get("data", {}).get("id")
                 loc = loc_map.get(str(loc_id), {})
+                
                 rows.append({
                     "lead_id": lead.get("id"),
                     "company_name": a.get("name"),
                     "website_url": a.get("website_url"),
+                    "phone": a.get("phone"),
+                    "business_id": a.get("business_id"),
                     "primary_industry": a.get("industry"),
+                    "all_industries": ", ".join([i.get("name") for i in a.get("industries", [])]) if a.get("industries") else None,
+                    "first_visit_date": a.get("first_visit_date"),
                     "last_visit_date": a.get("last_visit_date"),
                     "total_visits": a.get("visits"),
                     "lead_quality_score": a.get("quality"),
                     "revenue": a.get("revenue"),
                     "employee_count": a.get("employee_count"),
+                    "employees_min": a.get("employees_range", {}).get("min") if a.get("employees_range") else None,
+                    "employees_max": a.get("employees_range", {}).get("max") if a.get("employees_range") else None,
                     "assignee": a.get("assignee"),
+                    "emailed_to": a.get("emailed_to"),
+                    "crm_lead_id": a.get("crm_lead_id"),
                     "crm_organization_id": a.get("crm_organization_id"),
+                    "tags": ", ".join(a.get("tags", [])) if a.get("tags") else None,
                     "linkedin_url": a.get("linkedin_url"),
+                    "twitter_handle": a.get("twitter_handle"),
+                    "facebook_url": a.get("facebook_url"),
                     "country": loc.get("country"),
+                    "region": loc.get("region"),
                     "city": loc.get("city"),
+                    "leadfeeder_url": a.get("view_in_leadfeeder"),
                     "landing_page_path": None,
                     "exit_page_path": None
                 })
+            
+            print(f"✅ Page {page} loaded. Rows: {len(rows)}")
             page += 1
+            
         except Exception as e:
-            print(f"Error: {e}")
+            print(f"Error on page {page}: {e}")
             break
-    
+
     df = pd.DataFrame(rows)
     if not df.empty:
         df["last_visit_date"] = pd.to_datetime(df["last_visit_date"], errors="coerce")
     return df
 
-def enrich_leads_with_visits(df, start_date, end_date, max_rows=None):
-    if df.empty: return df
+def enrich_leads_with_visits(df, start_date, end_date, max_rows=None, progress=gr.Progress()):
+    """ 
+    Step 2: Deep enrich with visit_route parsing for Exit Page.
+    """
+    if df.empty:
+        return df
+
     target_df = df.head(max_rows) if max_rows else df
+    total = len(target_df)
+    
+    print(f"🕵️ Deep enriching {total} rows ({start_date} to {end_date})...")
     
     for index, row in target_df.iterrows():
-        if row.get("landing_page_path") and row.get("exit_page_path"): continue
-        
+        if row.get("landing_page_path") and row.get("exit_page_path"):
+            continue
+
         lead_id = row["lead_id"]
         try:
             visit_data = make_request(
                 f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads/{lead_id}/visits",
-                params={"start_date": start_date, "end_date": end_date, "page[size]": 1, "include": "page_views"}
+                params={
+                    "start_date": start_date,
+                    "end_date": end_date,
+                    "page[size]": 1, 
+                    "include": "page_views"
+                } 
             )
+            
             visits = visit_data.get("data", [])
             included = visit_data.get("included", [])
-            landing, exit_p = None, None
+            landing = None
+            exit_p = None
             
             if visits:
                 visit = visits[0]
                 v_attrs = visit.get("attributes", {})
+                
+                # A. Direct Attributes
                 landing = v_attrs.get("landing_page_path") or v_attrs.get("landing_page_url")
                 
-                # Visit Route Logic
+                # B. Parse 'visit_route'
                 visit_route = v_attrs.get("visit_route", [])
                 if visit_route and isinstance(visit_route, list):
-                    if not exit_p: exit_p = visit_route[-1].get("page_path") or visit_route[-1].get("page_url")
-                    if not landing: landing = visit_route[0].get("page_path") or visit_route[0].get("page_url")
-                
-                # Page View Logic
+                    last_step = visit_route[-1]
+                    if not exit_p: exit_p = last_step.get("page_path") or last_step.get("page_url")
+                    
+                    if not landing:
+                        first_step = visit_route[0]
+                        landing = first_step.get("page_path") or first_step.get("page_url")
+
+                # C. Deep Link via 'included' Page Views
                 if not landing or not exit_p:
                     pv_map = {p["id"]: p["attributes"] for p in included if p["type"] == "page_views"}
                     pv_ids = [r["id"] for r in visit.get("relationships", {}).get("page_views", {}).get("data", [])]
+                    
                     if pv_ids:
-                        if not landing: landing = pv_map.get(pv_ids[0], {}).get("url")
-                        if not exit_p: exit_p = pv_map.get(pv_ids[-1], {}).get("url")
-                        
+                        if not landing:
+                            first_pv = pv_map.get(pv_ids[0])
+                            if first_pv: landing = first_pv.get("url") or first_pv.get("path")
+                        if not exit_p:    
+                            last_pv = pv_map.get(pv_ids[-1])
+                            if last_pv: exit_p = last_pv.get("url") or last_pv.get("path")
+
                 df.at[index, "landing_page_path"] = landing
                 df.at[index, "exit_page_path"] = exit_p
-        except: pass
+        except Exception as e:
+            print(f"Failed to enrich lead {lead_id}: {e}")
+            
+        if max_rows and index % 5 == 0:
+            progress(index / total, desc="Enriching...")
+            
     return df
 
 # =====================================================
-# CHART BUILDERS (Plotly GO)
+# DEBUGGER
 # =====================================================
-def create_empty_figure(text="No Data Loaded"):
-    fig = go.Figure()
-    fig.update_layout(title=text, template="plotly_white")
-    return fig
+def inspect_raw_json(lead_id, start_date, end_date):
+    if not lead_id: return "Please enter a Lead ID"
+    try:
+        url = f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads/{lead_id}/visits"
+        params = {
+            "start_date": start_date, 
+            "end_date": end_date, 
+            "page[size]": 1, 
+            "include": "page_views"
+        }
+        r = requests.get(url, headers=HEADERS, params=params)
+        return json.dumps(r.json(), indent=2)
+    except Exception as e:
+        return str(e)
 
-def build_dashboard_chart(df, preset):
-    if df is None or df.empty: return create_empty_figure()
-    dim, metric, agg = DASHBOARD_PRESETS[preset]
+# =====================================================
+# DATA WRAPPERS
+# =====================================================
+def load_preview(start, end):
+    df = fetch_basic_leads(start, end)
+    if df.empty: return df, pd.DataFrame(), "⚠️ No data found."
+    
+    df_preview = df.copy()
+    df_preview = enrich_leads_with_visits(df_preview, start, end, max_rows=10)
     
+    status = f"✅ Loaded **{len(df):,} companies**. Preview shows top 10 rows enriched."
+    return df, df_preview.head(10), status
+
+def download_full_excel(df, start, end):
+    if df is None or df.empty: return None
+    print("⏳ Starting full enrichment for Excel export...")
+    enriched_df = enrich_leads_with_visits(df.copy(), start, end) 
+    path = "/tmp/leadfeeder_company_data_full.xlsx"
+    enriched_df.to_excel(path, index=False)
+    return path
+
+# =====================================================
+# CHART ENGINES
+# =====================================================
+def build_kpis(df):
+    if df is None or df.empty: return 0, 0, 0, 0, 0, 0
+    return (
+        len(df),
+        df["total_visits"].gt(0).sum(),
+        int(df["total_visits"].sum()),
+        round(df["lead_quality_score"].mean(), 2),
+        round(df["crm_organization_id"].notna().mean() * 100, 1),
+        round(df["linkedin_url"].notna().mean() * 100, 1),
+    )
+
+def build_dashboard(df, preset, top_n):
+    if df is None or df.empty: return px.bar(title="No Data")
+    dim, metric, agg = DASHBOARD_PRESETS[preset]
     if agg == "count":
         grouped = df.groupby(dim, dropna=False).size().reset_index(name="value")
     else:
         grouped = df.groupby(dim, dropna=False)[metric].agg(agg).reset_index(name="value")
-        
-    grouped = grouped.sort_values("value", ascending=False).head(15)
-    
-    fig = go.Figure(go.Bar(
-        x=grouped[dim], y=grouped["value"],
-        marker_color='#5898d4', text=grouped["value"], textposition='auto'
-    ))
-    fig.update_layout(title=f"<b>{preset}</b>", template="plotly_white", margin=dict(l=20,r=20,t=50,b=20))
-    return fig
+    return px.bar(grouped.sort_values("value", ascending=False).head(top_n), x=dim, y="value", title=preset)
 
-def build_trend_chart(df, preset, grain, filters):
-    if df is None or df.empty: return create_empty_figure()
+def get_trend_filter_options(df, preset):
+    if df is None or df.empty:
+        return gr.update(choices=[], value=None, visible=False)
     metric, agg, segment = TREND_PRESETS[preset]
-    df_c = df.dropna(subset=["last_visit_date"]).copy()
-    
-    if segment and filters:
-        df_c = df_c[df_c[segment].isin(filters)]
-        if df_c.empty: return create_empty_figure("No data for filters")
-        
-    if grain == "Weekly": df_c["period"] = df_c["last_visit_date"].dt.to_period("W").astype(str)
-    elif grain == "Monthly": df_c["period"] = df_c["last_visit_date"].dt.to_period("M").astype(str)
-    else: df_c["period"] = df_c["last_visit_date"].dt.date
-    
-    val = "_v" if agg == "count" else metric
-    if agg == "count": df_c["_v"] = df_c[metric].notna().astype(int)
-    
-    fig = go.Figure()
-    if segment:
-        ts = df_c.groupby(["period", segment])[val].agg(agg).reset_index()
-        for seg in ts[segment].unique():
-            seg_data = ts[ts[segment] == seg]
-            fig.add_trace(go.Scatter(x=seg_data["period"], y=seg_data[val], mode='lines+markers', name=str(seg)))
-    else:
-        ts = df_c.groupby("period")[val].agg(agg).reset_index()
-        fig.add_trace(go.Scatter(x=ts["period"], y=ts[val], mode='lines+markers', name="Total", line=dict(color='#00CC96', width=3)))
-        
-    fig.update_layout(title=f"<b>{preset}</b>", template="plotly_white")
-    return fig
-
-def build_advanced_charts(df, search_lead, search_comp, start, end):
-    if df is None or df.empty: return create_empty_figure(), create_empty_figure(), create_empty_figure()
-    
-    filtered_df = df.copy()
-    is_search = False
+    if not segment:
+        return gr.update(choices=[], value=None, visible=False)
+    options = sorted(df[segment].dropna().unique().tolist())
+    top_5 = df[segment].value_counts().head(5).index.tolist()
+    return gr.update(choices=options, value=top_5, visible=True, label=f"Filter {segment}")
+
+def build_trend(df, preset, grain, filter_values):
+    if df is None or df.empty: return px.line(title="No Data Loaded")
+    metric, agg, segment = TREND_PRESETS[preset]
+    df = df.dropna(subset=["last_visit_date"]).copy()
     
-    if search_lead:
-        filtered_df = filtered_df[filtered_df["lead_id"] == search_lead.strip()]
-        is_search = True
-    elif search_comp:
-        filtered_df = filtered_df[filtered_df["company_name"].str.contains(search_comp, case=False, na=False)]
-        is_search = True
-    else:
-        filtered_df = filtered_df.sort_values("total_visits", ascending=False).head(50)
-        
-    # Auto Enrich
-    missing = filtered_df[filtered_df["landing_page_path"].isnull()]
-    if not missing.empty:
-        enriched = enrich_leads_with_visits(missing, start, end)
-        filtered_df.update(enriched)
-        
-    # Sankey
-    flow_df = filtered_df.dropna(subset=["landing_page_path", "exit_page_path"])
-    if flow_df.empty:
-        sankey = create_empty_figure("No Flow Data")
-    else:
-        counts = flow_df.groupby(["landing_page_path", "exit_page_path"]).size().reset_index(name="count")
-        if not is_search: counts = counts.sort_values("count", ascending=False).head(15)
-        
-        all_nodes = list(pd.concat([counts["landing_page_path"], counts["exit_page_path"]]).unique())
-        node_map = {node: i for i, node in enumerate(all_nodes)}
-        
-        sankey = go.Figure(go.Sankey(
-            node=dict(pad=15, thickness=20, line=dict(color="black", width=0.5), label=all_nodes, color="blue"),
-            link=dict(source=counts["landing_page_path"].map(node_map), target=counts["exit_page_path"].map(node_map), value=counts["count"])
-        ))
-        sankey.update_layout(title="<b>User Flow: Landing → Exit</b>", font_size=10)
-
-    # Heatmap
-    temp_df = filtered_df.dropna(subset=["last_visit_date"]).copy()
-    if temp_df.empty:
-        heatmap = create_empty_figure("No Date Data")
+    if segment and filter_values:
+        df = df[df[segment].isin(filter_values)]
+        if df.empty: return px.line(title="No data for selected filters")
+
+    if grain == "Weekly":
+        df["period"] = df["last_visit_date"].dt.to_period("W").astype(str)
+    elif grain == "Monthly":
+        df["period"] = df["last_visit_date"].dt.to_period("M").astype(str)
     else:
-        temp_df["day"] = temp_df["last_visit_date"].dt.day_name()
-        temp_df["hour"] = temp_df["last_visit_date"].dt.hour
-        days_order = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-        hm_data = temp_df.groupby(["day", "hour"]).size().reset_index(name="visits")
-        hm_pivot = hm_data.pivot(index="day", columns="hour", values="visits").fillna(0).reindex(days_order)
+        df["period"] = df["last_visit_date"].dt.date
         
-        heatmap = go.Figure(go.Heatmap(z=hm_pivot.values, x=hm_pivot.columns, y=hm_pivot.index, colorscale='Viridis'))
-        heatmap.update_layout(title="<b>Activity Heatmap</b>")
-
-    # Matrix (Aggregate)
-    roi_df = df.groupby("primary_industry").agg({"total_visits": "sum", "lead_quality_score": "mean", "company_name": "count"}).reset_index()
-    roi_df = roi_df[roi_df["company_name"] > 2]
-    
-    if roi_df.empty:
-        matrix = create_empty_figure("Not enough data")
-    else:
-        matrix = go.Figure(go.Scatter(
-            x=roi_df["total_visits"], y=roi_df["lead_quality_score"], mode='markers', text=roi_df["primary_industry"],
-            marker=dict(size=roi_df["company_name"], sizemode='area', sizeref=2.*max(roi_df["company_name"])/(40.**2), sizemin=4, color=roi_df["lead_quality_score"], colorscale='RdYlGn', showscale=True)
-        ))
-        matrix.update_layout(title="<b>Industry Matrix</b>", xaxis_title="Volume", yaxis_title="Quality", template="plotly_white")
-
-    return sankey, heatmap, matrix
-
-# =====================================================
-# UI APPLICATION (NiceGUI)
-# =====================================================
-class LeadfeederApp:
-    def __init__(self):
-        self.df = pd.DataFrame()
-        self.start_date_val = (date.today() - timedelta(days=30)).isoformat()
-        self.end_date_val = date.today().isoformat()
-        
-    async def load_data(self):
-        if self.pwd_input.value != APP_PASSWORD:
-            ui.notify('Invalid Password!', type='negative')
-            return
-
-        self.loading_spinner.visible = True
-        ui.notify('Fetching data... this may take a moment.')
-        
-        # Run heavy fetch in background
-        self.df = await run.io_bound(fetch_basic_leads, self.date_start.value, self.date_end.value)
-        
-        if self.df.empty:
-            ui.notify('No data found.', type='warning')
-        else:
-            # Enrich top 10 for preview immediately
-            preview_df = self.df.copy()
-            preview_df = await run.io_bound(enrich_leads_with_visits, preview_df, self.date_start.value, self.date_end.value, 10)
-            
-            # Update UI
-            self.update_kpis()
-            self.update_aggrid(preview_df.head(10))
-            self.refresh_dashboard()
-            self.refresh_trends()
-            ui.notify(f'Loaded {len(self.df)} companies successfully!', type='positive')
-            
-        self.loading_spinner.visible = False
-
-    def update_kpis(self):
-        if self.df.empty: return
-        self.kpi_total.value = len(self.df)
-        self.kpi_visits.value = int(self.df["total_visits"].sum())
-        self.kpi_quality.value = round(self.df["lead_quality_score"].mean(), 2)
-        self.kpi_crm.value = f"{round(self.df['crm_organization_id'].notna().mean() * 100, 1)}%"
-
-    def update_aggrid(self, df_show):
-        # Convert timestamp to string for display
-        display_df = df_show.copy()
-        for col in display_df.select_dtypes(include=['datetime64']).columns:
-            display_df[col] = display_df[col].astype(str)
-        self.grid.options['rowData'] = display_df.to_dict(orient='records')
-        self.grid.update()
-
-    async def download_full_report(self):
-        if self.df.empty: return
-        ui.notify('Generating Excel... please wait.')
-        
-        # Run full enrichment
-        enriched_df = await run.io_bound(enrich_leads_with_visits, self.df.copy(), self.date_start.value, self.date_end.value)
+    val = metric
+    if agg == "count":
+        df["_v"] = df[metric].notna().astype(int)
+        val = "_v"
         
-        path = f"/tmp/leadfeeder_report_{int(time.time())}.xlsx"
-        enriched_df.to_excel(path, index=False)
-        ui.download(path)
-        ui.notify('Download started!', type='positive')
-
-    def refresh_dashboard(self):
-        fig = build_dashboard_chart(self.df, self.dash_preset.value)
-        self.dash_plot.update_figure(fig)
-
-    def update_trend_options(self):
-        if self.df.empty: return
-        _, _, segment = TREND_PRESETS[self.trend_preset.value]
-        if segment:
-            opts = sorted(self.df[segment].dropna().unique().tolist())
-            self.trend_filter.options = opts
-            self.trend_filter.visible = True
-        else:
-            self.trend_filter.visible = False
-            self.trend_filter.value = []
-
-    def refresh_trends(self):
-        fig = build_trend_chart(self.df, self.trend_preset.value, self.trend_grain.value, self.trend_filter.value)
-        self.trend_plot.update_figure(fig)
-
-    async def run_advanced_analytics(self):
-        if self.df.empty: return
-        ui.notify('Analyzing user flows...')
-        sankey, heatmap, matrix = await run.io_bound(
-            build_advanced_charts, self.df, self.adv_lead_id.value, self.adv_comp.value, 
-            self.date_start.value, self.date_end.value
-        )
-        self.sankey_plot.update_figure(sankey)
-        self.heatmap_plot.update_figure(heatmap)
-        self.matrix_plot.update_figure(matrix)
+    if segment:
+        ts = df.groupby(["period", segment])[val].agg(agg).reset_index()
+        title = f"{preset} (Filtered)" if filter_values else preset
+        return px.line(ts, x="period", y=val, color=segment, template="plotly_white", title=title)
     
-    async def run_debugger(self):
-        if not self.debug_id.value: return
-        res = await run.io_bound(
-            requests.get, 
-            f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads/{self.debug_id.value}/visits",
-            headers=HEADERS, 
-            params={"start_date": self.date_start.value, "end_date": self.date_end.value, "page[size]": 1, "include": "page_views"}
-        )
-        self.debug_output.set_content(f"```json\n{json.dumps(res.json(), indent=2)}\n```")
+    ts = df.groupby("period")[val].agg(agg).reset_index()
+    return px.line(ts, x="period", y=val, markers=True, template="plotly_white", title=preset)
 
 # =====================================================
 # UI LAYOUT
 # =====================================================
-@ui.page('/')
-def main_page():
-    app_logic = LeadfeederApp()
+with gr.Blocks(title="Leadfeeder Pro Analytics") as demo:
+    gr.Markdown("## 🚀 Leadfeeder Analytics")
     
-    # --- HEADER ---
-    with ui.header().classes(replace='row items-center') as header:
-        ui.icon('analytics', size='32px').classes('text-white q-mr-sm')
-        ui.label('Leadfeeder Pro Analytics').classes('text-h6 text-white')
-        ui.space()
-        app_logic.pwd_input = ui.input('App Password', password=True).classes('bg-white rounded q-px-sm')
-        
-    # --- TABS ---
-    with ui.tabs().classes('w-full') as tabs:
-        data_tab = ui.tab('Data & Report')
-        dash_tab = ui.tab('Dashboard')
-        trend_tab = ui.tab('Trends')
-        adv_tab = ui.tab('Advanced Analytics')
-        debug_tab = ui.tab('Debugger')
-
-    with ui.tab_panels(tabs, value=data_tab).classes('w-full q-pa-md'):
-        
+    with gr.Row():
+        pwd = gr.Textbox(type="password", label="App Password")
+        gr.Button("Auth").click(lambda p: gr.Info("Success") if p==APP_PASSWORD else gr.Error("Invalid"), pwd, None)
+    
+    df_state = gr.State()
+    status = gr.Markdown()
+    
+    with gr.Tabs():
         # --- TAB 1: DATA ---
-        with ui.tab_panel(data_tab):
-            with ui.row().classes('w-full items-center gap-4'):
-                app_logic.date_start = ui.input('Start Date', value=app_logic.start_date_val)
-                app_logic.date_end = ui.input('End Date', value=app_logic.end_date_val)
-                ui.button('Load Data', on_click=app_logic.load_data, icon='cloud_download')
-                ui.button('Download Excel (Full)', on_click=app_logic.download_full_report, icon='file_download').classes('bg-green')
-                app_logic.loading_spinner = ui.spinner(size='lg').props('color=primary').bind_visibility_from(app_logic.loading_spinner, 'visible')
-                app_logic.loading_spinner.visible = False
-
-            # KPIS
-            with ui.row().classes('w-full gap-4 q-my-md'):
-                with ui.card().classes('w-48'):
-                    ui.label('Total Companies').classes('text-caption')
-                    app_logic.kpi_total = ui.label('0').classes('text-h5')
-                with ui.card().classes('w-48'):
-                    ui.label('Total Visits').classes('text-caption')
-                    app_logic.kpi_visits = ui.label('0').classes('text-h5')
-                with ui.card().classes('w-48'):
-                    ui.label('Avg Quality').classes('text-caption')
-                    app_logic.kpi_quality = ui.label('0').classes('text-h5')
-                with ui.card().classes('w-48'):
-                    ui.label('CRM Coverage').classes('text-caption')
-                    app_logic.kpi_crm = ui.label('0%').classes('text-h5')
-
-            # PREVIEW GRID
-            ui.label('Data Preview (Top 10 Enriched)').classes('text-h6 q-mt-md')
-            app_logic.grid = ui.aggrid({
-                'columnDefs': [
-                    {'headerName': 'Company', 'field': 'company_name'},
-                    {'headerName': 'Industry', 'field': 'primary_industry'},
-                    {'headerName': 'Visits', 'field': 'total_visits'},
-                    {'headerName': 'Landing Page', 'field': 'landing_page_path'},
-                    {'headerName': 'Exit Page', 'field': 'exit_page_path'},
-                ],
-                'rowData': []
-            }).classes('h-96 w-full')
+        with gr.Tab("📋 Data & Report"):
+            with gr.Row():
+                start = gr.Textbox(label="Start Date", value=(date.today()-timedelta(days=30)).isoformat())
+                end = gr.Textbox(label="End Date", value=date.today().isoformat())
+            
+            with gr.Row():
+                btn_load = gr.Button("1. Load Data (Preview)", variant="primary")
+                btn_dl = gr.Button("2. Enrich & Download Full Excel")
+                file_dl = gr.File(label="Download Excel")
+            
+            table = gr.Dataframe(label="Preview (Top 10 Enriched)", interactive=True)
+            
+            btn_load.click(load_preview, [start, end], [df_state, table, status])
+            btn_dl.click(download_full_excel, [df_state, start, end], file_dl)
 
         # --- TAB 2: DASHBOARD ---
-        with ui.tab_panel(dash_tab):
-            with ui.row().classes('items-center'):
-                app_logic.dash_preset = ui.select(list(DASHBOARD_PRESETS.keys()), label="Select Chart", value="Total Visits by Industry", on_change=app_logic.refresh_dashboard).classes('w-64')
-                ui.button('Refresh', icon='refresh', on_click=app_logic.refresh_dashboard).props('flat')
+        with gr.Tab("📊 Dashboard"):
+            kpis = [gr.Number(label=l) for l in ["Total Companies", "Active Companies", "Total Visits", "Avg Quality", "CRM %", "LinkedIn %"]]
+            gr.Button("Refresh KPIs").click(build_kpis, df_state, kpis)
+            
+            with gr.Row():
+                preset = gr.Dropdown(choices=list(DASHBOARD_PRESETS.keys()), label="Chart")
+                top_n = gr.Slider(5, 50, value=10, label="Top N")
             
-            app_logic.dash_plot = ui.plotly({}).classes('w-full h-128')
+            chart = gr.Plot()
+            gr.Button("Build View").click(build_dashboard, [df_state, preset, top_n], chart)
 
         # --- TAB 3: TRENDS ---
-        with ui.tab_panel(trend_tab):
-            with ui.row().classes('items-start gap-4'):
-                app_logic.trend_preset = ui.select(list(TREND_PRESETS.keys()), label="Metric", value="Total Visits Trend", on_change=lambda: [app_logic.update_trend_options(), app_logic.refresh_trends()]).classes('w-64')
-                app_logic.trend_grain = ui.radio(['Daily', 'Weekly', 'Monthly'], value='Daily', on_change=app_logic.refresh_trends).props('inline')
-                app_logic.trend_filter = ui.select([], multiple=True, label="Filter Segments", on_change=app_logic.refresh_trends).classes('w-96').props('use-chips')
-                app_logic.trend_filter.visible = False
+        with gr.Tab("📈 Trends"):
+            with gr.Row():
+                trend_view = gr.Dropdown(choices=list(TREND_PRESETS.keys()), label="Select Trend")
+                grain = gr.Radio(["Daily", "Weekly", "Monthly"], value="Daily", label="Granularity")
             
-            app_logic.trend_plot = ui.plotly({}).classes('w-full h-128')
-
-        # --- TAB 4: ADVANCED ---
-        with ui.tab_panel(adv_tab):
-            with ui.row().classes('items-center gap-4'):
-                app_logic.adv_lead_id = ui.input('Search Lead ID')
-                app_logic.adv_comp = ui.input('Search Company Name')
-                ui.button('Analyze Flow', on_click=app_logic.run_advanced_analytics, icon='insights')
-
-            with ui.row().classes('w-full'):
-                with ui.column().classes('w-1/2'):
-                    app_logic.sankey_plot = ui.plotly({}).classes('w-full h-96')
-                with ui.column().classes('w-1/2'):
-                    app_logic.heatmap_plot = ui.plotly({}).classes('w-full h-96')
+            filter_dropdown = gr.Dropdown(multiselect=True, visible=False, label="Filter Segments")
+            plot = gr.Plot()
             
-            app_logic.matrix_plot = ui.plotly({}).classes('w-full h-96 q-mt-md')
+            trend_view.change(get_trend_filter_options, [df_state, trend_view], filter_dropdown)
+            gr.Button("Show Trend", variant="primary").click(
+                build_trend, 
+                [df_state, trend_view, grain, filter_dropdown], 
+                plot
+            )
 
-        # --- TAB 5: DEBUGGER ---
-        with ui.tab_panel(debug_tab):
-            with ui.row():
-                app_logic.debug_id = ui.input('Lead ID')
-                ui.button('Inspect JSON', on_click=app_logic.run_debugger)
-            app_logic.debug_output = ui.markdown('Raw JSON will appear here...')
+        # --- TAB 4: DEBUGGER ---
+        with gr.Tab("🛠️ Debugger"):
+            gr.Markdown("Inspect raw API data for a specific lead.")
+            dbg_id = gr.Textbox(label="Lead ID")
+            dbg_btn = gr.Button("Inspect Raw JSON")
+            dbg_out = gr.Code(language="json")
+            dbg_btn.click(inspect_raw_json, [dbg_id, start, end], dbg_out)
 
-ui.run(title='Leadfeeder Analytics', port=8080, favicon='🚀')
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)