Update main.py

main.py

@@ -338,67 +338,198 @@ def sanitize_answer(ans) -> str:
     if tb in s: s = s.split(tb, 1)[0]
     return (s or "").strip()
 
+
+
+# -------------------- Robust normalizers (paste once, near your engine class) --------------------
+from typing import Any, Iterable, List, Dict, Optional
+import json
+import pandas as pd
+import numpy as np
+
+def _to_list(x: Any) -> List[Any]:
+    """Return x as a list. Accept list/dict/JSON-string/None gracefully."""
+    if x is None:
+        return []
+    if isinstance(x, list):
+        return x
+    if isinstance(x, dict):
+        return [x]
+    if isinstance(x, str):
+        # try to parse JSON strings like '[{...}]' or '{"a":1}'
+        try:
+            j = json.loads(x)
+            if isinstance(j, list):
+                return j
+            if isinstance(j, dict):
+                return [j]
+        except Exception:
+            return [x]  # treat as scalar string row (will be skipped later)
+    return [x]
+
+def _to_float(x: Any) -> Optional[float]:
+    try:
+        if x is None or (isinstance(x, str) and not x.strip()):
+            return None
+        return float(str(x).replace(",", "").strip())
+    except Exception:
+        return None
+
+def _to_int(x: Any) -> Optional[int]:
+    try:
+        f = _to_float(x)
+        return int(f) if f is not None else None
+    except Exception:
+        return None
+
+def _coerce_date(s: Any) -> Optional[pd.Timestamp]:
+    if s is None:
+        return None
+    try:
+        dt = pd.to_datetime(s, errors="coerce")
+        if pd.isna(dt):
+            return None
+        # align to Harare if naive; respects your global TZ
+        try:
+            return dt.tz_localize(TZ, nonexistent="shift_forward", ambiguous="NaT")
+        except Exception:
+            return dt.tz_convert(TZ)
+    except Exception:
+        return None
+
+# -------------------- Hardened sales series (drop-in replacement) --------------------
+
 # -----------------------------------------------------------------------------
 # Admin KPI Engine (holistic view)
 # -----------------------------------------------------------------------------
 class AdminAnalyticsEngine:
     """Single-tenant holistic admin analytics. No shop/brand filters; admin sees entire dataset."""
     def __init__(self, tenant_key: str, email: str, password: str, period: str = "week"):
-        self.tenant_key = tenant_key or "admin"
-        self.email = email
-        self.password = password
+        self.tenant_key = (tenant_key or "admin").strip()
+        self.email = (email or "").strip()
+        self.password = (password or "").strip()
         self.period = (period or "week").lower().strip()
         self.t_start, self.t_end, self.period_label = period_to_bounds(self.period)
 
+    # -------------------- helpers --------------------
+    @staticmethod
+    def _unwrap_data(payload: dict) -> dict:
+        if isinstance(payload, dict):
+            # common backend pattern: {"status":"success","data":{...}}
+            return payload.get("data") if isinstance(payload.get("data"), dict) else payload
+        return {}
+
     # -------------------- API pulls (no shop/brand params at all) --------------------
     def _dashboard(self) -> dict:
-        data = sc_request("GET", "/api/analytics/dashboard", self.email, self.password, params={"period": self.period})
-        emit_kpi_debug(self.tenant_key, "dashboard", data)
+        raw = sc_request(
+            "GET",
+            "/api/analytics/dashboard",
+            self.email,
+            self.password,
+            params={"period": self.period},
+        )
+        data = self._unwrap_data(raw)
+        emit_kpi_debug(self.tenant_key, "dashboard", data or raw or {})
         return data or {}
 
     def _sales_series(self) -> pd.DataFrame:
+        """
+        Fetches /api/analytics/sales and returns a tidy daily series:
+        columns: ['_date','total_sales','total_orders','aov']
+        - Robust to strings/dicts/mixed payloads
+        - Converts numeric strings to floats/ints
+        - Skips malformed rows instead of crashing
+        """
         params = {
             "start_date": self.t_start.strftime("%Y-%m-%d"),
             "end_date": self.t_end.strftime("%Y-%m-%d"),
-            "group_by": "day"
+            "group_by": "day",
         }
-        data = sc_request("GET", "/api/analytics/sales", self.email, self.password, params=params)
-        emit_kpi_debug(self.tenant_key, "sales_series_raw", data)
-        rows = []
-        seq = (data.get("data") if isinstance(data, dict) else data) or []
-        for r in seq:
-            rows.append({
-                "date": str(r.get("date") or r.get("day") or r.get("period") or ""),
-                "revenue": float(r.get("revenue") or r.get("total") or 0.0),
-                "orders": int(r.get("orders") or r.get("transactions") or 0),
-                "gross_profit": float(r.get("gross_profit") or r.get("gp") or 0.0),
+        raw = sc_request("GET", "/api/analytics/sales", self.email, self.password, params=params)
+
+        # Expect raw like:
+        # {"status":"success","data":{"sales_over_time":[{"date":"YYYY-MM-DD","total_sales":"141.11","total_orders":3}], ...}}
+        data = {}
+        if isinstance(raw, dict):
+            data = (raw.get("data") or raw) if isinstance(raw.get("data"), (dict, list)) else raw
+        else:
+            try:
+                j = json.loads(raw)
+                data = j.get("data", j) if isinstance(j, dict) else {}
+            except Exception:
+                data = {}
+
+        series = []
+        sales_ot = data.get("sales_over_time")
+        for r in _to_list(sales_ot):
+            if not isinstance(r, dict):
+                continue
+            date_str = r.get("date") or r.get("day") or r.get("period")
+            dt = _coerce_date(date_str)
+            if dt is None:
+                continue
+
+            total_sales = _to_float(r.get("total_sales") or r.get("total") or r.get("revenue"))
+            total_orders = _to_int(r.get("total_orders") or r.get("orders") or r.get("count"))
+            aov = _to_float(r.get("average_order_value") or r.get("aov"))
+
+            if aov is None and total_sales is not None and (total_orders or 0) > 0:
+                aov = float(total_sales) / int(total_orders)
+
+            series.append({
+                "_date": dt,
+                "total_sales": float(total_sales) if total_sales is not None else 0.0,
+                "total_orders": int(total_orders) if total_orders is not None else 0,
+                "aov": float(aov) if aov is not None else None,
             })
-        df = pd.DataFrame(rows)
-        if not df.empty:
-            df["date"] = pd.to_datetime(df["date"], errors="coerce").dt.tz_localize(_TZ, nonexistent="shift_forward")
+
+        df = pd.DataFrame(series)
+        if df.empty:
+            return pd.DataFrame(columns=["_date", "total_sales", "total_orders", "aov"])
+
+        df = df.sort_values("_date").reset_index(drop=True)
+        emit_kpi_debug(self.tenant_key, "sales_series_raw", (raw if isinstance(raw, dict) else {"raw": raw}))
         return df
 
     def _products(self) -> dict:
-        data = sc_request("GET", "/api/analytics/products", self.email, self.password,
-                          params={"start_date": self.t_start.strftime("%Y-%m-%d"), "end_date": self.t_end.strftime("%Y-%m-%d")})
-        emit_kpi_debug(self.tenant_key, "products", data)
+        raw = sc_request(
+            "GET",
+            "/api/analytics/products",
+            self.email,
+            self.password,
+            params={"start_date": self.t_start.strftime("%Y-%m-%d"), "end_date": self.t_end.strftime("%Y-%m-%d")},
+        )
+        data = self._unwrap_data(raw)
+        emit_kpi_debug(self.tenant_key, "products", data or raw or {})
         return data or {}
 
     def _customers(self) -> dict:
-        data = sc_request("GET", "/api/analytics/customers", self.email, self.password,
-                          params={"start_date": self.t_start.strftime("%Y-%m-%d"), "end_date": self.t_end.strftime("%Y-%m-%d")})
-        emit_kpi_debug(self.tenant_key, "customers", data)
+        raw = sc_request(
+            "GET",
+            "/api/analytics/customers",
+            self.email,
+            self.password,
+            params={"start_date": self.t_start.strftime("%Y-%m-%d"), "end_date": self.t_end.strftime("%Y-%m-%d")},
+        )
+        data = self._unwrap_data(raw)
+        emit_kpi_debug(self.tenant_key, "customers", data or raw or {})
         return data or {}
 
     def _inventory(self) -> dict:
-        data = sc_request("GET", "/api/analytics/inventory", self.email, self.password)
-        emit_kpi_debug(self.tenant_key, "inventory", data)
+        raw = sc_request("GET", "/api/analytics/inventory", self.email, self.password)
+        data = self._unwrap_data(raw)
+        emit_kpi_debug(self.tenant_key, "inventory", data or raw or {})
         return data or {}
 
     def _comparisons(self) -> dict:
-        data = sc_request("GET", "/api/analytics/comparisons", self.email, self.password,
-                          params={"start_date": self.t_start.strftime("%Y-%m-%d"), "end_date": self.t_end.strftime("%Y-%m-%d")})
-        emit_kpi_debug(self.tenant_key, "comparisons", data)
+        raw = sc_request(
+            "GET",
+            "/api/analytics/comparisons",
+            self.email,
+            self.password,
+            params={"start_date": self.t_start.strftime("%Y-%m-%d"), "end_date": self.t_end.strftime("%Y-%m-%d")},
+        )
+        data = self._unwrap_data(raw)
+        emit_kpi_debug(self.tenant_key, "comparisons", data or raw or {})
         return data or {}
 
     # -------------------- deterministic snapshot --------------------
@@ -410,14 +541,27 @@ class AdminAnalyticsEngine:
         inv = self._inventory()
         comps = self._comparisons()
 
-        try:
-            total_revenue = float(dash.get("total_revenue", 0.0))
-            gross_profit = float(dash.get("gross_profit", 0.0) or dash.get("gp", 0.0))
-            transactions = int(dash.get("transactions", dash.get("orders", 0)))
-        except Exception:
-            total_revenue = float(sales_df["revenue"].sum()) if not sales_df.empty else 0.0
-            gross_profit = float(sales_df["gross_profit"].sum()) if not sales_df.empty else 0.0
-            transactions = int(sales_df["orders"].sum()) if not sales_df.empty else 0
+        # Dashboard numbers can be at the top level or under 'metrics' etc.
+        # We’ll try a few keys before falling back to sums from sales_df.
+        def _get_num(d: dict, *keys, default=0.0):
+            for k in keys:
+                v = d.get(k)
+                if isinstance(v, (int, float, str)):
+                    try:
+                        return float(v)
+                    except Exception:
+                        continue
+            return default
+
+        total_revenue = _get_num(dash, "total_revenue", "revenue", default=0.0)
+        gross_profit = _get_num(dash, "gross_profit", "gp", default=0.0)
+        transactions = int(_get_num(dash, "transactions", "orders", default=0.0))
+
+        if (total_revenue == 0.0 or transactions == 0) and isinstance(sales_df, pd.DataFrame) and not sales_df.empty:
+            # Fallback: use the sales series we just fetched
+            total_revenue = float(sales_df["total_sales"].sum())
+            transactions = int(sales_df["total_orders"].sum())
+            # We don't have GP in this endpoint; leave as 0.0 if not provided by dashboard
 
         product_lb = {
             "top_by_revenue": prods.get("top_by_revenue") or prods.get("topRevenue") or [],
@@ -435,7 +579,7 @@ class AdminAnalyticsEngine:
                 "new_customers": custs.get("new_customers", []),
             },
             "rfm_summary": custs.get("summary", {}),
-            "params": {"window": self.period_label}
+            "params": {"window": self.period_label},
         }
 
         temporal = self._temporal_patterns_from_sales(sales_df)
@@ -443,20 +587,20 @@ class AdminAnalyticsEngine:
         inventory_block = {
             "status": "ok" if inv else "no_stock_data",
             "alerts": inv.get("alerts") if isinstance(inv, dict) else {},
-            "snapshot": inv
+            "snapshot": inv,
         }
 
         snapshot = {
             "Summary Period": f"{self.period_label} ({self.t_start.date()} to {self.t_end.date()})",
             "Performance Snapshot": {
-                "Total Revenue": total_revenue,
-                "Gross Profit": gross_profit,
+                "Total Revenue": round(total_revenue, 2),
+                "Gross Profit": round(gross_profit, 2),
                 "Transactions": transactions,
                 "Change": {
                     "revenue": dash.get("revenue_change") or dash.get("total_revenue_change"),
                     "gross_profit": dash.get("gross_profit_change") or dash.get("gp_change"),
-                    "transactions": dash.get("transactions_change") or dash.get("orders_change")
-                }
+                    "transactions": dash.get("transactions_change") or dash.get("orders_change"),
+                },
             },
             "Temporal Patterns": temporal,
             "Product KPIs": {"leaderboards": product_lb},
@@ -467,26 +611,45 @@ class AdminAnalyticsEngine:
                 "timeframes": {
                     "current_start": self.t_start.isoformat(),
                     "current_end": self.t_end.isoformat(),
-                    "period_label": self.period_label
+                    "period_label": self.period_label,
+                },
+                "row_counts": {
+                    "sales_points": int(len(sales_df)) if isinstance(sales_df, pd.DataFrame) else 0
                 },
-                "row_counts": {"sales_points": int(len(sales_df)) if isinstance(sales_df, pd.DataFrame) else 0}
-            }
+            },
         }
         emit_kpi_debug(self.tenant_key, "snapshot_done", snapshot["meta"])
         return json_safe(snapshot)
 
     def _temporal_patterns_from_sales(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Build simple temporal readouts from the sales series returned by _sales_series():
+        - series: [{date, total_sales, total_orders, aov}]
+        - best_day_by_sales: highest total_sales by weekday
+        """
         if df is None or df.empty:
-            return {"series": [], "best_day_by_profit": None}
+            return {"series": [], "best_day_by_sales": None}
+
         d = df.copy()
-        d["dow"] = d["date"].dt.day_name()
-        by_dow = d.groupby("dow", dropna=False).agg(revenue=("revenue","sum"), gross_profit=("gross_profit","sum")).reset_index()
-        best_day = None
-        if not by_dow.empty:
-            best = by_dow.iloc[by_dow["gross_profit"].idxmax()]
-            best_day = {"day": str(best["dow"]), "gross_profit": float(best["gross_profit"])}
-        series = d.sort_values("date").assign(date=lambda x: x["date"].dt.strftime("%Y-%m-%d")).to_dict(orient="records")
-        return {"series": series, "best_day_by_profit": best_day}
+        # Derive DOW and safe date strings
+        d["dow"] = d["_date"].dt.day_name()
+        d["date"] = d["_date"].dt.strftime("%Y-%m-%d")
+
+        # Aggregate by DOW using total_sales as revenue proxy
+        g = d.groupby("dow", dropna=False).agg(
+            total_sales=("total_sales", "sum"),
+            total_orders=("total_orders", "sum"),
+        ).reset_index()
+
+        best_row = None if g.empty else g.loc[g["total_sales"].idxmax()]
+        best_day = None if g.empty else {
+            "day": str(best_row["dow"]),
+            "total_sales": float(best_row["total_sales"]),
+            "total_orders": int(best_row["total_orders"]),
+        }
+
+        series = d[["date", "total_sales", "total_orders", "aov"]].to_dict(orient="records")
+        return {"series": series, "best_day_by_sales": best_day}
 
     def narrate(self, snapshot: dict, user_question: str) -> str:
         try:
@@ -501,7 +664,6 @@ class AdminAnalyticsEngine:
             return sanitize_answer(text)
         except Exception:
             return "### Business Snapshot\n\n```\n" + json.dumps(json_safe(snapshot), indent=2) + "\n```"
-
 # -----------------------------------------------------------------------------
 # /chat — PandasAI first on sales series, else deterministic snapshot + narration
 # -----------------------------------------------------------------------------