snowglobe-cli 0.2.2__tar.gz → 0.2.4__tar.gz

{snowglobe_cli-0.2.2 → snowglobe_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowglobe-cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: Explainable cost and access visibility for Snowflake
 Author-email: Jaryd Thornton <jaryd90@gmail.com>
 License-Expression: Apache-2.0

{snowglobe_cli-0.2.2 → snowglobe_cli-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "snowglobe-cli"
-version = "0.2.2"
+version = "0.2.4"
 description = "Explainable cost and access visibility for Snowflake"
 readme = "README.md"
 requires-python = ">=3.12.3"

{snowglobe_cli-0.2.2 → snowglobe_cli-0.2.4}/snowglobe/core/cost_service.py

@@ -1171,7 +1171,7 @@ class CostService:
         d = _sq(date)
         svc_upper = service_type.upper()
 
-        if svc_upper == "WAREHOUSE_METERING":
+        if "WAREHOUSE" in svc_upper:
             safe_wh = _sq(resource)
             conn = self.context.connect()
             try:
@@ -1335,3 +1335,132 @@ class CostService:
             return df, "Query Attribution not enabled — showing slowest queries"
         except Exception:
             return pd.DataFrame(), "Could not load queries"
+
+    def get_user_warehouse_queries(
+        self, user_name: str, warehouse_name: str, days: int = 7, limit: int = 10
+    ) -> tuple[pd.DataFrame, str | None]:
+        """Top queries for a user on a specific warehouse over the past N days."""
+        safe_user = _sq(user_name)
+        safe_wh = _sq(warehouse_name)
+        conn = self.context.connect()
+        try:
+            with conn:
+                rows = conn.query(f"""
+                    SELECT a.QUERY_ID,
+                           ROUND(a.CREDITS_ATTRIBUTED_COMPUTE, 4) AS CREDITS,
+                           q.QUERY_TYPE,
+                           LEFT(q.QUERY_TEXT, 80) AS QUERY_PREVIEW,
+                           ROUND(q.TOTAL_ELAPSED_TIME / 1000, 1) AS SECONDS,
+                           ROUND(q.BYTES_SCANNED / 1e9, 2) AS GB_SCANNED
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY a
+                    LEFT JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY q ON a.QUERY_ID = q.QUERY_ID
+                    WHERE a.START_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                      AND a.WAREHOUSE_NAME = '{safe_wh}'
+                      AND a.USER_NAME = '{safe_user}'
+                    ORDER BY a.CREDITS_ATTRIBUTED_COMPUTE DESC
+                    LIMIT {limit}
+                """)
+            if not rows:
+                return pd.DataFrame(), None
+            df = pd.DataFrame(rows)
+            df["CREDITS"] = df["CREDITS"].astype(float)
+            return df, None
+        except Exception:
+            pass
+
+        conn2 = self.context.connect()
+        try:
+            with conn2:
+                rows = conn2.query(f"""
+                    SELECT QUERY_ID, 0.0 AS CREDITS, QUERY_TYPE,
+                           LEFT(QUERY_TEXT, 80) AS QUERY_PREVIEW,
+                           ROUND(TOTAL_ELAPSED_TIME / 1000, 1) AS SECONDS,
+                           ROUND(BYTES_SCANNED / 1e9, 2) AS GB_SCANNED
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
+                    WHERE START_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                      AND WAREHOUSE_NAME = '{safe_wh}'
+                      AND USER_NAME = '{safe_user}'
+                      AND EXECUTION_STATUS = 'SUCCESS'
+                    ORDER BY TOTAL_ELAPSED_TIME DESC
+                    LIMIT {limit}
+                """)
+            if not rows:
+                return pd.DataFrame(), "Query Attribution not enabled — showing slowest queries"
+            df = pd.DataFrame(rows)
+            df["CREDITS"] = df["CREDITS"].astype(float)
+            return df, "Query Attribution not enabled — showing slowest queries"
+        except Exception:
+            return pd.DataFrame(), "Could not load queries"
+
+    def get_ai_service_users(self, service_name: str, days: int = 30) -> tuple[pd.DataFrame, str | None]:
+        """Users of a specific AI/Cortex service over the past N days."""
+        _empty = pd.DataFrame(columns=["USER_NAME", "CREDITS", "REQUESTS"])
+        sql_map = {
+            "Cortex Functions": f"""
+                SELECT u.LOGIN_NAME AS USER_NAME,
+                       ROUND(SUM(f.credits), 4) AS CREDITS, COUNT(*) AS REQUESTS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY f
+                INNER JOIN SNOWFLAKE.ACCOUNT_USAGE.USERS u ON u.USER_ID = f.USER_ID
+                WHERE f.START_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                  AND f.credits > 0
+                GROUP BY 1 ORDER BY 2 DESC LIMIT 50
+            """,
+            "Cortex Analyst": f"""
+                SELECT USERNAME AS USER_NAME,
+                       ROUND(SUM(credits), 4) AS CREDITS, COUNT(*) AS REQUESTS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_ANALYST_USAGE_HISTORY
+                WHERE START_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                  AND credits > 0
+                GROUP BY 1 ORDER BY 2 DESC LIMIT 50
+            """,
+            "Cortex Agent": f"""
+                SELECT USER_NAME,
+                       ROUND(SUM(token_credits), 4) AS CREDITS, COUNT(*) AS REQUESTS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AGENT_USAGE_HISTORY
+                WHERE START_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                  AND token_credits > 0
+                GROUP BY 1 ORDER BY 2 DESC LIMIT 50
+            """,
+            "Cortex Code": f"""
+                SELECT USER_NAME,
+                       ROUND(SUM(token_credits), 4) AS CREDITS, COUNT(*) AS REQUESTS
+                FROM (
+                    SELECT USER_NAME, token_credits
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_CLI_USAGE_HISTORY
+                    WHERE USAGE_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                      AND token_credits > 0
+                    UNION ALL
+                    SELECT USER_NAME, token_credits
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_SNOWSIGHT_USAGE_HISTORY
+                    WHERE USAGE_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                      AND token_credits > 0
+                    UNION ALL
+                    SELECT USER_NAME, token_credits
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_DESKTOP_USAGE_HISTORY
+                    WHERE USAGE_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                      AND token_credits > 0
+                ) GROUP BY 1 ORDER BY 2 DESC LIMIT 50
+            """,
+            "Snowflake Intelligence": f"""
+                SELECT USER_NAME,
+                       ROUND(SUM(token_credits), 4) AS CREDITS, COUNT(*) AS REQUESTS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.SNOWFLAKE_INTELLIGENCE_USAGE_HISTORY
+                WHERE START_TIME >= DATEADD('day', -{days}, CURRENT_TIMESTAMP())
+                  AND token_credits > 0
+                GROUP BY 1 ORDER BY 2 DESC LIMIT 50
+            """,
+        }
+        sql = sql_map.get(service_name)
+        if not sql:
+            return _empty, f"No user breakdown available for: {service_name}"
+        conn = self.context.connect()
+        try:
+            with conn:
+                rows = conn.query(sql)
+            if not rows:
+                return _empty, None
+            df = pd.DataFrame(rows)
+            df["CREDITS"] = df["CREDITS"].astype(float)
+            return df, None
+        except Exception:
+            return _empty, "Could not load user breakdown"

{snowglobe_cli-0.2.2 → snowglobe_cli-0.2.4}/snowglobe/tui/screens/cost.py

@@ -40,16 +40,22 @@ class CostScreen(Vertical):
 
     # Active view: "summary" | "trend" | "top_queries" | "warehouses" | "users"
     # | "ai" | "ai_users" | "services" | "storage" | "replication" | "mv" | "budget"
-    # | "drill_service" | "drill_warehouse" | "drill_user"
+    # | "drill_service" | "drill_warehouse" | "drill_user" | "drill_user_queries"
+    # | "drill_ai_service"
     # | "drill_day" | "drill_day_resource" | "drill_day_resource_users" | "drill_day_user_queries"
     _current_view: str = "summary"
     _drill_service: str | None = None
     _drill_warehouse: str | None = None
     _drill_user: str | None = None
+    _drill_user_warehouse: str | None = None      # warehouse selected in drill_user
+    _drill_ai_service: str | None = None          # AI service selected in ai view
     _drill_day: str | None = None
     _drill_day_service_type: str | None = None
     _drill_day_resource: str | None = None
     _drill_day_user: str | None = None
+    _drill_day_resource_kind: str = "other"       # "warehouse" | "ai" | "other"
+    _drill_day_parent: str = "trend"              # "trend" | "drill_service"
+    _drill_resource_users_parent: str = "drill_day_resource"  # or "drill_warehouse"
     # Becomes True after the user explicitly picks a view, so Select.Changed
     # events fired during the initial mount don't auto-trigger a Snowflake fetch.
     _user_initiated: bool = False
@@ -146,16 +152,37 @@ class CostScreen(Vertical):
         elif self._current_view == "trend":
             self._drill_day = key
             self._fetch_day_drill(key)
+        elif self._current_view == "drill_service":
+            # Date row in service daily trend → full day drill (same chain as Trend)
+            self._drill_day_parent = "drill_service"
+            self._fetch_day_drill(key)
+        elif self._current_view == "drill_warehouse":
+            # Date row in warehouse daily trend → jump to Level 3 (users on that day)
+            self._drill_day = key
+            self._drill_day_service_type = "WAREHOUSE_METERING"
+            self._drill_day_resource_kind = "warehouse"
+            self._drill_resource_users_parent = "drill_warehouse"
+            self._fetch_day_resource_users(key, "WAREHOUSE_METERING", self._drill_warehouse)
+        elif self._current_view == "drill_user":
+            # Warehouse row in user detail → top queries for user+warehouse
+            self._fetch_user_queries(self._drill_user, key)
+        elif self._current_view == "ai":
+            self._fetch_ai_service_users(key)
+        elif self._current_view == "drill_user_queries":
+            try:
+                from textual.widgets import ContentSwitcher, Input
+                from snowglobe.tui.screens.tune import TuneScreen
+                self.app.query_one(ContentSwitcher).current = "tune"
+                tune = self.app.query_one(TuneScreen)
+                tune.query_one("#tu-query-id", Input).value = key
+                self.app.notify(f"Loaded {key[:24]}… into Tune. Press Analyse.", timeout=4)
+            except Exception:
+                self.app.notify(f"Query: {key[:24]}…", timeout=4)
         elif self._current_view == "drill_day":
             self._drill_day_service_type = key
             self._fetch_day_resource_drill(self._drill_day, key)
         elif self._current_view == "drill_day_resource":
-            upper = (self._drill_day_service_type or "").upper()
-            can_drill = (
-                upper == _WAREHOUSE_SERVICE_TYPE
-                or any(kw in upper for kw in _AI_SERVICE_KEYWORDS)
-            )
-            if can_drill:
+            if self._drill_day_resource_kind in ("warehouse", "ai"):
                 self._fetch_day_resource_users(
                     self._drill_day, self._drill_day_service_type, key
                 )
@@ -164,7 +191,7 @@ class CostScreen(Vertical):
                     "No user-level detail available for this resource type.", timeout=3
                 )
         elif self._current_view == "drill_day_resource_users":
-            if (self._drill_day_service_type or "").upper() == _WAREHOUSE_SERVICE_TYPE:
+            if self._drill_day_resource_kind == "warehouse":
                 self._fetch_day_user_queries(self._drill_day, self._drill_day_resource, key)
             else:
                 self.app.notify("No query detail available for AI services.", timeout=3)
@@ -221,6 +248,10 @@ class CostScreen(Vertical):
             self._fetch_warehouse_drill(self._drill_warehouse)
         elif self._current_view == "drill_user" and self._drill_user:
             self._fetch_user_drill(self._drill_user)
+        elif self._current_view == "drill_user_queries" and self._drill_user and self._drill_user_warehouse:
+            self._fetch_user_queries(self._drill_user, self._drill_user_warehouse)
+        elif self._current_view == "drill_ai_service" and self._drill_ai_service:
+            self._fetch_ai_service_users(self._drill_ai_service)
         elif self._current_view == "drill_day" and self._drill_day:
             self._fetch_day_drill(self._drill_day)
         elif self._current_view == "drill_day_resource" and self._drill_day and self._drill_day_service_type:
@@ -246,16 +277,30 @@ class CostScreen(Vertical):
         elif self._current_view == "drill_user":
             self._drill_user = None
             self._fetch_users()
+        elif self._current_view == "drill_user_queries":
+            self._drill_user_warehouse = None
+            self._fetch_user_drill(self._drill_user)
+        elif self._current_view == "drill_ai_service":
+            self._drill_ai_service = None
+            self._fetch_ai()
         elif self._current_view == "drill_day":
             self._drill_day = None
             self._drill_day_service_type = None
-            self._fetch_trend()
+            if self._drill_day_parent == "drill_service":
+                self._drill_day_parent = "trend"
+                self._fetch_service_drill(self._drill_service)
+            else:
+                self._fetch_trend()
         elif self._current_view == "drill_day_resource":
             self._drill_day_service_type = None
             self._fetch_day_drill(self._drill_day)
         elif self._current_view == "drill_day_resource_users":
             self._drill_day_resource = None
-            self._fetch_day_resource_drill(self._drill_day, self._drill_day_service_type)
+            if self._drill_resource_users_parent == "drill_warehouse":
+                self._drill_resource_users_parent = "drill_day_resource"
+                self._fetch_warehouse_drill(self._drill_warehouse)
+            else:
+                self._fetch_day_resource_drill(self._drill_day, self._drill_day_service_type)
         elif self._current_view == "drill_day_user_queries":
             self._drill_day_user = None
             self._fetch_day_resource_users(
@@ -317,6 +362,7 @@ class CostScreen(Vertical):
 
     def _fetch_trend(self, force: bool = False) -> None:
         self._current_view = "trend"
+        self._reset_table()
         self._set_status(f"Loading daily trend ({self._days()}d)…")
         self._trend_worker(days=self._days(), force=force)
 
@@ -330,6 +376,8 @@ class CostScreen(Vertical):
         self.app.call_from_thread(self._render_trend, df, days, cache_age)
 
     def _render_trend(self, df: pd.DataFrame, days: int, cache_age: int | None) -> None:
+        if self._current_view != "trend":
+            return  # stale callback
         if df is None or df.empty:
             self._set_status("No trend data found.")
             self._clear_table()
@@ -417,6 +465,7 @@ class CostScreen(Vertical):
 
     def _fetch_service_drill(self, service_type: str, force: bool = False) -> None:
         self._current_view = "drill_service"
+        self._reset_table()
         self._set_status(f"Loading daily trend for {service_type} ({self._days()}d)…  Esc to return")
         self._drill_worker(service_type=service_type, days=self._days())
 
@@ -430,15 +479,17 @@ class CostScreen(Vertical):
         self.app.call_from_thread(self._render_service_drill, df, service_type, days)
 
     def _render_service_drill(self, df: pd.DataFrame, service_type: str, days: int) -> None:
+        if self._current_view != "drill_service":
+            return
         if df is None or df.empty:
             self._set_status(f"No daily data for {service_type} ({days}d). Esc to return.")
             self._clear_table()
             return
         total = float(df["CREDITS"].sum())
         self._set_status(
-            f"{service_type} daily trend — {days}d  ·  total {total:,.2f}  ·  Esc to return"
+            f"{service_type} daily trend — {days}d  ·  total {total:,.2f}"
+            f"  ·  click date to drill  ·  Esc to return"
         )
-
         table = self.query_one(DataTable)
         self._reset_table()
         table.add_columns("DATE", "CREDITS", "TREND")
@@ -446,7 +497,8 @@ class CostScreen(Vertical):
         for _, row in df.iterrows():
             credits = float(row["CREDITS"])
             ratio = credits / max_c if max_c > 0 else 0
-            table.add_row(str(row["DATE"]), f"{credits:,.2f}", _bar(ratio))
+            table.add_row(str(row["DATE"]), f"{credits:,.2f}", _bar(ratio),
+                          key=str(row["DATE"]))
 
     # --- View 4: Warehouses ------------------------------------------
 
@@ -489,6 +541,7 @@ class CostScreen(Vertical):
 
     def _fetch_warehouse_drill(self, warehouse_name: str) -> None:
         self._current_view = "drill_warehouse"
+        self._reset_table()
         self._set_status(f"Loading daily trend for {warehouse_name} ({self._days()}d)…  Esc to return")
         self._warehouse_drill_worker(warehouse_name=warehouse_name, days=self._days())
 
@@ -502,13 +555,16 @@ class CostScreen(Vertical):
         self.app.call_from_thread(self._render_warehouse_drill, df, warehouse_name, days)
 
     def _render_warehouse_drill(self, df: pd.DataFrame, warehouse_name: str, days: int) -> None:
+        if self._current_view != "drill_warehouse":
+            return
         if df is None or df.empty:
             self._set_status(f"No daily data for {warehouse_name} ({days}d).  Esc to return")
             self._clear_table()
             return
         total = float(df["CREDITS"].sum())
         self._set_status(
-            f"{warehouse_name} daily — {days}d  ·  total {total:,.2f}  ·  Esc to return"
+            f"{warehouse_name} daily — {days}d  ·  total {total:,.2f}"
+            f"  ·  click date to see users  ·  Esc to return"
         )
         table = self.query_one(DataTable)
         self._reset_table()
@@ -517,7 +573,8 @@ class CostScreen(Vertical):
         for _, row in df.iterrows():
             credits = float(row["CREDITS"])
             ratio = credits / max_c if max_c > 0 else 0
-            table.add_row(str(row["DATE"]), f"{credits:,.2f}", _bar(ratio))
+            table.add_row(str(row["DATE"]), f"{credits:,.2f}", _bar(ratio),
+                          key=str(row["DATE"]))
 
     # --- View 5: Users -----------------------------------------------
 
@@ -571,6 +628,7 @@ class CostScreen(Vertical):
 
     def _fetch_user_drill(self, user_name: str) -> None:
         self._current_view = "drill_user"
+        self._reset_table()
         self._set_status(f"Loading warehouse detail for {user_name} ({min(self._days(),7)}d)…  Esc to return")
         self._user_drill_worker(user_name=user_name, days=min(self._days(), 7))
 
@@ -584,6 +642,8 @@ class CostScreen(Vertical):
         self.app.call_from_thread(self._render_user_drill, df, user_name, days, note)
 
     def _render_user_drill(self, df: pd.DataFrame, user_name: str, days: int, note: str | None) -> None:
+        if self._current_view != "drill_user":
+            return
         if df is None or df.empty:
             self._set_status(f"No attribution data for {user_name} ({days}d).  Esc to return")
             self._clear_table()
@@ -591,7 +651,8 @@ class CostScreen(Vertical):
         total = float(df["CREDITS"].sum())
         note_suffix = f"  ·  ⚠ {note}" if note else ""
         self._set_status(
-            f"{user_name} per-warehouse — {days}d  ·  total {total:,.4f}{note_suffix}  ·  Esc to return"
+            f"{user_name} per-warehouse — {days}d  ·  total {total:,.4f}{note_suffix}"
+            f"  ·  click warehouse for top queries  ·  Esc to return"
         )
         no_credits = note is not None
         table = self.query_one(DataTable)
@@ -605,12 +666,117 @@ class CostScreen(Vertical):
                 credits_str,
                 str(int(row.get("QUERY_COUNT", 0))),
                 avg_str,
+                key=str(row.get("WAREHOUSE_NAME", "")),
+            )
+
+    # --- Drill: top queries for user+warehouse (from drill_user) -----
+
+    def _fetch_user_queries(self, user_name: str, warehouse_name: str) -> None:
+        self._current_view = "drill_user_queries"
+        self._drill_user_warehouse = warehouse_name
+        self._reset_table()
+        self._set_status(
+            f"Loading top queries for {user_name} on {warehouse_name}…  Esc to return"
+        )
+        self._user_queries_worker(
+            user_name=user_name, warehouse_name=warehouse_name, days=min(self._days(), 7)
+        )
+
+    @work(thread=True, exclusive=True, group="cost")
+    def _user_queries_worker(self, *, user_name: str, warehouse_name: str, days: int) -> None:
+        try:
+            df, note = self.app.get_cost_service().get_user_warehouse_queries(
+                user_name, warehouse_name, days
+            )
+        except Exception as e:
+            self.app.call_from_thread(self._fetch_failed, e)
+            return
+        self.app.call_from_thread(self._render_user_queries, df, user_name, warehouse_name, note)
+
+    def _render_user_queries(
+        self, df: pd.DataFrame, user_name: str, warehouse_name: str, note: str | None
+    ) -> None:
+        if self._current_view != "drill_user_queries":
+            return
+        self._reset_table()
+        table = self.query_one(DataTable)
+        note_suffix = f"  ·  ⚠ {note}" if note else ""
+        if df is None or df.empty:
+            table.add_columns("(no queries found)")
+            self._set_status(
+                f"{user_name} on {warehouse_name}  ·  no queries{note_suffix}  ·  Esc to return"
+            )
+            return
+        table.add_columns("CREDITS", "TYPE", "SECONDS", "GB", "PREVIEW")
+        for _, row in df.iterrows():
+            table.add_row(
+                f"{float(row.get('CREDITS', 0)):,.4f}",
+                str(row.get("QUERY_TYPE", "")),
+                f"{float(row.get('SECONDS', 0)):.1f}",
+                f"{float(row.get('GB_SCANNED', 0)):.2f}",
+                str(row.get("QUERY_PREVIEW", ""))[:48],
+                key=str(row.get("QUERY_ID", "")),
             )
+        self._set_status(
+            f"Top queries — {user_name} on {warehouse_name}{note_suffix}"
+            f"  ·  ⏎ open in Tune  ·  Esc to return"
+        )
+
+    # --- Drill: users of an AI service (from ai view) ----------------
+
+    def _fetch_ai_service_users(self, service_name: str) -> None:
+        self._current_view = "drill_ai_service"
+        self._drill_ai_service = service_name
+        self._reset_table()
+        self._set_status(
+            f"Loading users for {service_name} ({self._days()}d)…  Esc to return"
+        )
+        self._ai_service_users_worker(service_name=service_name, days=self._days())
+
+    @work(thread=True, exclusive=True, group="cost")
+    def _ai_service_users_worker(self, *, service_name: str, days: int) -> None:
+        try:
+            df, note = self.app.get_cost_service().get_ai_service_users(service_name, days)
+        except Exception as e:
+            self.app.call_from_thread(self._fetch_failed, e)
+            return
+        self.app.call_from_thread(self._render_ai_service_users, df, service_name, days, note)
+
+    def _render_ai_service_users(
+        self, df: pd.DataFrame, service_name: str, days: int, note: str | None
+    ) -> None:
+        if self._current_view != "drill_ai_service":
+            return
+        self._reset_table()
+        table = self.query_one(DataTable)
+        note_suffix = f"  ·  ⚠ {note}" if note else ""
+        if df is None or df.empty:
+            table.add_columns("(no users found)")
+            self._set_status(f"{service_name}  ·  no users{note_suffix}  ·  Esc to return")
+            return
+        total = float(df["CREDITS"].sum())
+        max_c = float(df["CREDITS"].max()) if total > 0 else 1.0
+        table.add_columns("USER", "CREDITS", "REQUESTS", "% OF SERVICE", "BAR")
+        for _, row in df.iterrows():
+            credits = float(row["CREDITS"])
+            pct = (credits / total * 100) if total > 0 else 0
+            table.add_row(
+                str(row["USER_NAME"]),
+                f"{credits:,.4f}",
+                str(int(row.get("REQUESTS", 0))),
+                f"{pct:.1f}%",
+                _bar(credits / max_c),
+            )
+        self._set_status(
+            f"{service_name} users — {days}d  ·  total {total:,.4f}{note_suffix}  ·  Esc to return"
+        )
 
     # --- Drill: day breakdown (Level 1 — service types) --------------
 
     def _fetch_day_drill(self, date: str) -> None:
+        self._drill_day = date  # always set — this may be called from home.py or back-nav
         self._current_view = "drill_day"
+        self._reset_table()  # clear immediately so stale rows can't be re-clicked while loading
         self._set_status(f"Loading service breakdown for {date}…  Esc to return")
         self._day_drill_worker(date=date)
 
@@ -624,6 +790,8 @@ class CostScreen(Vertical):
         self.app.call_from_thread(self._render_day_drill, df, date)
 
     def _render_day_drill(self, df: pd.DataFrame, date: str) -> None:
+        if self._current_view != "drill_day":
+            return  # stale callback — view advanced before this fired
         self._reset_table()
         table = self.query_one(DataTable)
         if df is None or df.empty:
@@ -652,13 +820,28 @@ class CostScreen(Vertical):
     def _fetch_day_resource_drill(self, date: str, service_type: str) -> None:
         self._current_view = "drill_day_resource"
         self._drill_day_service_type = service_type
-        self._set_status(f"Loading {service_type} breakdown for {date}…  Esc to return")
         upper = service_type.upper()
         is_ai = any(kw in upper for kw in _AI_SERVICE_KEYWORDS)
-        self._day_resource_drill_worker(date=date, service_type=service_type, is_ai=is_ai)
+        is_warehouse = "WAREHOUSE" in upper
+        # Set kind synchronously — before async work — so navigation is correct
+        # even if the worker fails and the render never fires.
+        if is_ai:
+            self._drill_day_resource_kind = "ai"
+        elif is_warehouse:
+            self._drill_day_resource_kind = "warehouse"
+        else:
+            self._drill_day_resource_kind = "other"
+        # Clear table immediately so stale Level 1 rows can't be clicked while loading.
+        self._reset_table()
+        self._set_status(f"Loading {service_type} breakdown for {date}…  Esc to return")
+        self._day_resource_drill_worker(
+            date=date, service_type=service_type, is_ai=is_ai, is_warehouse=is_warehouse
+        )
 
     @work(thread=True, exclusive=True, group="cost")
-    def _day_resource_drill_worker(self, *, date: str, service_type: str, is_ai: bool) -> None:
+    def _day_resource_drill_worker(
+        self, *, date: str, service_type: str, is_ai: bool, is_warehouse: bool
+    ) -> None:
         try:
             svc = self.app.get_cost_service()
             if is_ai:
@@ -666,6 +849,11 @@ class CostScreen(Vertical):
                 label = "AI Service"
                 found = True
                 note = "some Cortex views unavailable" if any_missing else None
+            elif is_warehouse:
+                df = svc.get_day_warehouse_breakdown(date)
+                label = "Warehouse"
+                found = True
+                note = None
             else:
                 df, label, found = svc.get_day_resource_breakdown(date, service_type)
                 note = None
@@ -678,6 +866,8 @@ class CostScreen(Vertical):
 
     def _render_day_resource_drill(self, df: pd.DataFrame, date: str, service_type: str,
                                     label: str, found: bool, note: str | None) -> None:
+        if self._current_view != "drill_day_resource":
+            return  # stale callback
         self._reset_table()
         table = self.query_one(DataTable)
         note_suffix = f"  ·  ⚠ {note}" if note else ""
@@ -706,12 +896,11 @@ class CostScreen(Vertical):
                 cells.append(str(int(row.get("REQUEST_COUNT", 0))))
             cells += [f"{pct:.1f}%", _bar(credits / max_c)]
             table.add_row(*cells, key=str(row["RESOURCE_NAME"]))
-        upper = service_type.upper()
-        can_drill_users = (
-            upper == _WAREHOUSE_SERVICE_TYPE
-            or any(kw in upper for kw in _AI_SERVICE_KEYWORDS)
+        user_hint = (
+            "  ·  click to see users"
+            if self._drill_day_resource_kind in ("warehouse", "ai")
+            else ""
         )
-        user_hint = "  ·  click to see users" if can_drill_users else ""
         self._set_status(
             f"{service_type} — {date}  ·  {total:,.4f} credits{note_suffix}{user_hint}  ·  Esc to return"
         )
@@ -721,6 +910,7 @@ class CostScreen(Vertical):
     def _fetch_day_resource_users(self, date: str, service_type: str, resource: str) -> None:
         self._current_view = "drill_day_resource_users"
         self._drill_day_resource = resource
+        self._reset_table()
         self._set_status(f"Loading users for {resource} on {date}…  Esc to return")
         self._day_resource_users_worker(date=date, service_type=service_type, resource=resource)
 
@@ -737,6 +927,8 @@ class CostScreen(Vertical):
 
     def _render_day_resource_users(self, df: pd.DataFrame, date: str,
                                     resource: str, note: str | None) -> None:
+        if self._current_view != "drill_day_resource_users":
+            return  # stale callback
         self._reset_table()
         table = self.query_one(DataTable)
         note_suffix = f"  ·  ⚠ {note}" if note else ""
@@ -764,7 +956,7 @@ class CostScreen(Vertical):
             )
         query_hint = (
             "  ·  click user to see top queries"
-            if (self._drill_day_service_type or "").upper() == _WAREHOUSE_SERVICE_TYPE
+            if self._drill_day_resource_kind == "warehouse"
             else ""
         )
         self._set_status(
@@ -776,6 +968,7 @@ class CostScreen(Vertical):
     def _fetch_day_user_queries(self, date: str, warehouse: str, user: str) -> None:
         self._current_view = "drill_day_user_queries"
         self._drill_day_user = user
+        self._reset_table()
         self._set_status(
             f"Loading top queries for {user} on {warehouse} ({date})…  Esc to return"
         )
@@ -794,6 +987,8 @@ class CostScreen(Vertical):
 
     def _render_day_user_queries(self, df: pd.DataFrame, date: str,
                                   warehouse: str, user: str, note: str | None) -> None:
+        if self._current_view != "drill_day_user_queries":
+            return  # stale callback
         self._reset_table()
         table = self.query_one(DataTable)
         note_suffix = f"  ·  ⚠ {note}" if note else ""

{snowglobe_cli-0.2.2 → snowglobe_cli-0.2.4}/snowglobe_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowglobe-cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: Explainable cost and access visibility for Snowflake
 Author-email: Jaryd Thornton <jaryd90@gmail.com>
 License-Expression: Apache-2.0