snowglobe-cli 0.2.1__tar.gz → 0.2.3__tar.gz

{snowglobe_cli-0.2.1 → snowglobe_cli-0.2.3}/PKG-INFO

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

{snowglobe_cli-0.2.1 → snowglobe_cli-0.2.3}/pyproject.toml

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

{snowglobe_cli-0.2.1 → snowglobe_cli-0.2.3}/snowglobe/core/cost_service.py

@@ -952,22 +952,386 @@ class CostService:
             # View may not exist if no MVs are used
             return pd.DataFrame(), None
 
-    def get_day_detail(self, date: str) -> pd.DataFrame:
+    def get_day_warehouse_breakdown(self, date: str) -> pd.DataFrame:
         """Warehouse credit breakdown for a single calendar day."""
         conn = self.context.connect()
         with conn:
             rows = conn.query(f"""
-                SELECT WAREHOUSE_NAME,
+                SELECT WAREHOUSE_NAME AS RESOURCE_NAME,
                        ROUND(SUM(CREDITS_USED), 4) AS CREDITS
                 FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
-                WHERE START_TIME::DATE = '{date}'
+                WHERE START_TIME::DATE = '{_sq(date)}'
                   AND WAREHOUSE_NAME IS NOT NULL
-                GROUP BY 1
-                ORDER BY 2 DESC
-                LIMIT 30
+                GROUP BY 1 ORDER BY 2 DESC LIMIT 50
             """)
         if not rows:
-            return pd.DataFrame(columns=["WAREHOUSE_NAME", "CREDITS"])
+            return pd.DataFrame(columns=["RESOURCE_NAME", "CREDITS"])
         df = pd.DataFrame(rows)
         df["CREDITS"] = df["CREDITS"].astype(float)
         return df
+
+    def get_day_service_breakdown(self, date: str) -> pd.DataFrame:
+        """All service types and credit totals for a single calendar day."""
+        conn = self.context.connect()
+        with conn:
+            rows = conn.query(f"""
+                SELECT SERVICE_TYPE,
+                       ROUND(SUM(CREDITS_BILLED), 4) AS CREDITS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.METERING_DAILY_HISTORY
+                WHERE USAGE_DATE = '{_sq(date)}'
+                  AND SERVICE_TYPE IS NOT NULL
+                GROUP BY 1 ORDER BY 2 DESC
+            """)
+        if not rows:
+            return pd.DataFrame(columns=["SERVICE_TYPE", "CREDITS"])
+        df = pd.DataFrame(rows)
+        df["CREDITS"] = df["CREDITS"].astype(float)
+        return df
+
+    def get_day_resource_breakdown(self, date: str, service_type: str) -> tuple[pd.DataFrame, str, bool]:
+        """
+        Resource-level credits for a service type on a single calendar day.
+        Returns (df, resource_label, found).
+        found=False when service_type has no known backing view.
+        """
+        _empty = pd.DataFrame(columns=["RESOURCE_NAME", "CREDITS"])
+        d = _sq(date)
+        s = service_type.upper()
+
+        candidates = [
+            (
+                s == "WAREHOUSE_METERING",
+                "Warehouse",
+                f"""SELECT WAREHOUSE_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
+                    WHERE START_TIME::DATE = '{d}' AND WAREHOUSE_NAME IS NOT NULL
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+            (
+                "PIPE" in s or "SNOWPIPE" in s,
+                "Pipe",
+                f"""SELECT PIPE_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.PIPE_USAGE_HISTORY
+                    WHERE START_TIME::DATE = '{d}'
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+            (
+                "TASK" in s,
+                "Task",
+                f"""SELECT DATABASE_NAME || '.' || SCHEMA_NAME || '.' || TASK_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.SERVERLESS_TASK_HISTORY
+                    WHERE START_TIME::DATE = '{d}'
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+            (
+                "CONTAINER" in s or "SPCS" in s or "SNOWPARK" in s,
+                "Compute Pool",
+                f"""SELECT COMPUTE_POOL_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.SNOWPARK_CONTAINER_SERVICES_HISTORY
+                    WHERE START_TIME::DATE = '{d}'
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+            (
+                "CLUSTERING" in s,
+                "Table",
+                f"""SELECT DATABASE_NAME || '.' || SCHEMA_NAME || '.' || TABLE_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.AUTOMATIC_CLUSTERING_HISTORY
+                    WHERE START_TIME::DATE = '{d}'
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+            (
+                "SEARCH" in s,
+                "Table",
+                f"""SELECT DATABASE_NAME || '.' || SCHEMA_NAME || '.' || TABLE_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.SEARCH_OPTIMIZATION_HISTORY
+                    WHERE START_TIME::DATE = '{d}'
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+            (
+                "REPLICATION" in s,
+                "Replication Group",
+                f"""SELECT REPLICATION_GROUP_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.REPLICATION_GROUP_USAGE_HISTORY
+                    WHERE START_TIME::DATE = '{d}'
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+            (
+                "MATERIALIZED" in s or s == "MV",
+                "Materialized View",
+                f"""SELECT DATABASE_NAME || '.' || SCHEMA_NAME || '.' || TABLE_NAME AS RESOURCE_NAME,
+                           ROUND(SUM(CREDITS_USED), 4) AS CREDITS
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.MATERIALIZED_VIEW_REFRESH_HISTORY
+                    WHERE START_TIME::DATE = '{d}'
+                    GROUP BY 1 ORDER BY 2 DESC LIMIT 50""",
+            ),
+        ]
+
+        conn = self.context.connect()
+        for matches, label, sql in candidates:
+            if not matches:
+                continue
+            try:
+                with conn:
+                    rows = conn.query(sql)
+                if not rows:
+                    return _empty, label, True
+                df = pd.DataFrame(rows)
+                df["CREDITS"] = df["CREDITS"].astype(float)
+                return df, label, True
+            except Exception:
+                return _empty, label, True
+
+        return _empty, service_type, False
+
+    def get_day_ai_breakdown(self, date: str) -> tuple[pd.DataFrame, bool]:
+        """Cortex AI service credit breakdown for a single calendar day."""
+        d = _sq(date)
+        sources = [
+            ("Cortex Functions", f"""
+                SELECT u.LOGIN_NAME AS USER_NAME, 'Cortex Functions' AS SERVICE,
+                       f.credits AS TOKEN_CREDITS
+                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::DATE = '{d}' AND f.credits > 0
+            """),
+            ("Cortex Analyst", f"""
+                SELECT USERNAME AS USER_NAME, 'Cortex Analyst' AS SERVICE,
+                       credits AS TOKEN_CREDITS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_ANALYST_USAGE_HISTORY
+                WHERE START_TIME::DATE = '{d}' AND credits > 0
+            """),
+            ("Cortex Agent", f"""
+                SELECT USER_NAME, 'Cortex Agent' AS SERVICE, token_credits AS TOKEN_CREDITS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AGENT_USAGE_HISTORY
+                WHERE START_TIME::DATE = '{d}' AND token_credits > 0
+            """),
+            ("Cortex Code", f"""
+                SELECT USER_NAME, 'Cortex Code' AS SERVICE, token_credits AS TOKEN_CREDITS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_CLI_USAGE_HISTORY
+                WHERE USAGE_TIME::DATE = '{d}' AND token_credits > 0
+                UNION ALL
+                SELECT USER_NAME, 'Cortex Code', token_credits
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_SNOWSIGHT_USAGE_HISTORY
+                WHERE USAGE_TIME::DATE = '{d}' AND token_credits > 0
+                UNION ALL
+                SELECT USER_NAME, 'Cortex Code', token_credits
+                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_DESKTOP_USAGE_HISTORY
+                WHERE USAGE_TIME::DATE = '{d}' AND token_credits > 0
+            """),
+            ("Snowflake Intelligence", f"""
+                SELECT USER_NAME, 'Snowflake Intelligence' AS SERVICE,
+                       token_credits AS TOKEN_CREDITS
+                FROM SNOWFLAKE.ACCOUNT_USAGE.SNOWFLAKE_INTELLIGENCE_USAGE_HISTORY
+                WHERE START_TIME::DATE = '{d}' AND token_credits > 0
+            """),
+        ]
+        frames = []
+        any_missing = False
+        conn = self.context.connect()
+        with conn:
+            for _, sql in sources:
+                try:
+                    rows = conn.query(sql)
+                    if rows:
+                        frames.append(pd.DataFrame(rows))
+                except Exception:
+                    any_missing = True
+
+        _empty = pd.DataFrame(columns=["RESOURCE_NAME", "CREDITS", "REQUEST_COUNT"])
+        if not frames:
+            return _empty, any_missing
+
+        raw = pd.concat(frames, ignore_index=True)
+        raw["TOKEN_CREDITS"] = raw["TOKEN_CREDITS"].astype(float)
+        df = (
+            raw.groupby("SERVICE")
+            .agg(CREDITS=("TOKEN_CREDITS", "sum"), REQUEST_COUNT=("TOKEN_CREDITS", "count"))
+            .reset_index()
+            .rename(columns={"SERVICE": "RESOURCE_NAME"})
+            .sort_values("CREDITS", ascending=False)
+            .reset_index(drop=True)
+        )
+        df["CREDITS"] = df["CREDITS"].round(4)
+        return df, any_missing
+
+    def get_day_resource_users(self, date: str, service_type: str, resource: str) -> tuple[pd.DataFrame, str | None]:
+        """
+        User breakdown for a specific resource on a single calendar day.
+        Supports WAREHOUSE_METERING (QUERY_ATTRIBUTION_HISTORY) and AI/Cortex types.
+        Returns (df[USER_NAME, CREDITS, REQUESTS], note).
+        """
+        _empty = pd.DataFrame(columns=["USER_NAME", "CREDITS", "REQUESTS"])
+        d = _sq(date)
+        svc_upper = service_type.upper()
+
+        if svc_upper == "WAREHOUSE_METERING":
+            safe_wh = _sq(resource)
+            conn = self.context.connect()
+            try:
+                with conn:
+                    rows = conn.query(f"""
+                        SELECT USER_NAME,
+                               ROUND(SUM(CREDITS_ATTRIBUTED_COMPUTE), 4) AS CREDITS,
+                               COUNT(*) AS REQUESTS
+                        FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
+                        WHERE START_TIME::DATE = '{d}'
+                          AND WAREHOUSE_NAME = '{safe_wh}'
+                        GROUP BY 1 ORDER BY 2 DESC LIMIT 50
+                    """)
+                if not rows:
+                    return _empty, 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 USER_NAME, 0.0 AS CREDITS, COUNT(*) AS REQUESTS
+                        FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
+                        WHERE START_TIME::DATE = '{d}'
+                          AND WAREHOUSE_NAME = '{safe_wh}'
+                          AND EXECUTION_STATUS = 'SUCCESS'
+                        GROUP BY 1 ORDER BY 3 DESC LIMIT 50
+                    """)
+                if not rows:
+                    return _empty, None
+                df = pd.DataFrame(rows)
+                df["CREDITS"] = df["CREDITS"].astype(float)
+                return df, "Query Attribution not enabled — showing query counts only"
+            except Exception:
+                return _empty, None
+
+        _ai_kw = ("AI", "CORTEX", "INTELLIGENCE")
+        if not any(kw in svc_upper for kw in _ai_kw):
+            return _empty, "No user-level detail available for this service type"
+
+        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::DATE = '{d}' 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::DATE = '{d}' 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::DATE = '{d}' 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::DATE = '{d}' AND token_credits > 0
+                    UNION ALL
+                    SELECT USER_NAME, token_credits
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_SNOWSIGHT_USAGE_HISTORY
+                    WHERE USAGE_TIME::DATE = '{d}' AND token_credits > 0
+                    UNION ALL
+                    SELECT USER_NAME, token_credits
+                    FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_DESKTOP_USAGE_HISTORY
+                    WHERE USAGE_TIME::DATE = '{d}' 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::DATE = '{d}' AND token_credits > 0
+                GROUP BY 1 ORDER BY 2 DESC LIMIT 50
+            """,
+        }
+        sql = sql_map.get(resource)
+        if not sql:
+            return _empty, f"No user breakdown available for: {resource}"
+        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"
+
+    def get_day_user_queries(self, date: str, warehouse: str, user: str, limit: int = 3) -> tuple[pd.DataFrame, str | None]:
+        """Top queries for a user on a specific warehouse+date.
+        Uses QUERY_ATTRIBUTION_HISTORY; falls back to QUERY_HISTORY ranked by elapsed time."""
+        d = _sq(date)
+        safe_wh = _sq(warehouse)
+        safe_user = _sq(user)
+        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::DATE = '{d}'
+                      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::DATE = '{d}'
+                      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"

{snowglobe_cli-0.2.1 → snowglobe_cli-0.2.3}/snowglobe/tui/screens/cost.py

@@ -20,6 +20,8 @@ from textual.widgets import Button, DataTable, Label, ListItem, ListView, Select
 
 
 _BAR_WIDTH = 24  # max █ characters in trend column
+_WAREHOUSE_SERVICE_TYPE = "WAREHOUSE_METERING"
+_AI_SERVICE_KEYWORDS = ("AI", "CORTEX", "INTELLIGENCE")
 
 
 def _bar(pct_or_ratio: float, width: int = _BAR_WIDTH) -> str:
@@ -38,12 +40,17 @@ 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_day"
+    # | "drill_service" | "drill_warehouse" | "drill_user"
+    # | "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_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"
     # 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
@@ -140,6 +147,33 @@ class CostScreen(Vertical):
         elif self._current_view == "trend":
             self._drill_day = key
             self._fetch_day_drill(key)
+        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":
+            if self._drill_day_resource_kind in ("warehouse", "ai"):
+                self._fetch_day_resource_users(
+                    self._drill_day, self._drill_day_service_type, key
+                )
+            else:
+                self.app.notify(
+                    "No user-level detail available for this resource type.", timeout=3
+                )
+        elif self._current_view == "drill_day_resource_users":
+            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)
+        elif self._current_view == "drill_day_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 == "top_queries":
             # Hand off to Tune via the App's content switcher.
             try:
@@ -185,6 +219,18 @@ class CostScreen(Vertical):
             self._fetch_user_drill(self._drill_user)
         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:
+            self._fetch_day_resource_drill(self._drill_day, self._drill_day_service_type)
+        elif (self._current_view == "drill_day_resource_users"
+              and self._drill_day and self._drill_day_service_type and self._drill_day_resource):
+            self._fetch_day_resource_users(
+                self._drill_day, self._drill_day_service_type, self._drill_day_resource
+            )
+        elif (self._current_view == "drill_day_user_queries"
+              and self._drill_day and self._drill_day_resource and self._drill_day_user):
+            self._fetch_day_user_queries(
+                self._drill_day, self._drill_day_resource, self._drill_day_user
+            )
 
     def action_back_from_drill(self) -> None:
         if self._current_view == "drill_service":
@@ -198,7 +244,19 @@ class CostScreen(Vertical):
             self._fetch_users()
         elif self._current_view == "drill_day":
             self._drill_day = None
+            self._drill_day_service_type = None
             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)
+        elif self._current_view == "drill_day_user_queries":
+            self._drill_day_user = None
+            self._fetch_day_resource_users(
+                self._drill_day, self._drill_day_service_type, self._drill_day_resource
+            )
 
     # --- Days helper --------------------------------------------------
 
@@ -545,17 +603,17 @@ class CostScreen(Vertical):
                 avg_str,
             )
 
-    # --- Drill: day detail -------------------------------------------
+    # --- Drill: day breakdown (Level 1 — service types) --------------
 
     def _fetch_day_drill(self, date: str) -> None:
         self._current_view = "drill_day"
-        self._set_status(f"Loading breakdown for {date}…  Esc to return")
+        self._set_status(f"Loading service breakdown for {date}…  Esc to return")
         self._day_drill_worker(date=date)
 
     @work(thread=True, exclusive=True, group="cost")
     def _day_drill_worker(self, *, date: str) -> None:
         try:
-            df = self.app.get_cost_service().get_day_detail(date)
+            df = self.app.get_cost_service().get_day_service_breakdown(date)
         except Exception as e:
             self.app.call_from_thread(self._fetch_failed, e)
             return
@@ -565,23 +623,203 @@ class CostScreen(Vertical):
         self._reset_table()
         table = self.query_one(DataTable)
         if df is None or df.empty:
-            table.add_columns("(no warehouse activity on this date)")
+            table.add_columns("(no activity on this date)")
             self._set_status(f"{date}  ·  no data  ·  Esc to return")
             return
         total = float(df["CREDITS"].sum())
         max_c = float(df["CREDITS"].max()) if total > 0 else 1.0
-        table.add_columns("WAREHOUSE", "CREDITS", "% OF DAY", "BAR")
+        table.add_columns("SERVICE TYPE", "CREDITS", "% OF DAY", "BAR")
         for _, row in df.iterrows():
             credits = float(row["CREDITS"])
             pct = (credits / total * 100) if total > 0 else 0
             table.add_row(
-                str(row["WAREHOUSE_NAME"]),
+                str(row["SERVICE_TYPE"]),
                 f"{credits:,.4f}",
                 f"{pct:.1f}%",
                 _bar(credits / max_c),
+                key=str(row["SERVICE_TYPE"]),
+            )
+        self._set_status(
+            f"Day breakdown — {date}  ·  {total:,.4f} credits  ·  click a service to drill  ·  Esc to return"
+        )
+
+    # --- Drill: resource breakdown (Level 2 — all service types) -----
+
+    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)
+
+    @work(thread=True, exclusive=True, group="cost")
+    def _day_resource_drill_worker(self, *, date: str, service_type: str, is_ai: bool) -> None:
+        try:
+            svc = self.app.get_cost_service()
+            if is_ai:
+                df, any_missing = svc.get_day_ai_breakdown(date)
+                label = "AI Service"
+                found = True
+                note = "some Cortex views unavailable" if any_missing else None
+            else:
+                df, label, found = svc.get_day_resource_breakdown(date, service_type)
+                note = None
+        except Exception as e:
+            self.app.call_from_thread(self._fetch_failed, e)
+            return
+        self.app.call_from_thread(
+            self._render_day_resource_drill, df, date, service_type, label, found, note, is_ai
+        )
+
+    def _render_day_resource_drill(self, df: pd.DataFrame, date: str, service_type: str,
+                                    label: str, found: bool, note: str | None,
+                                    is_ai: bool = False) -> None:
+        # Store kind so navigation decisions don't depend on the SERVICE_TYPE string.
+        if is_ai:
+            self._drill_day_resource_kind = "ai"
+        elif label == "Warehouse":
+            self._drill_day_resource_kind = "warehouse"
+        else:
+            self._drill_day_resource_kind = "other"
+
+        self._reset_table()
+        table = self.query_one(DataTable)
+        note_suffix = f"  ·  ⚠ {note}" if note else ""
+        if not found:
+            table.add_columns("(no detail available for this service type)")
+            self._set_status(
+                f"{service_type} — {date}  ·  no resource detail available  ·  Esc to return"
+            )
+            return
+        if df is None or df.empty:
+            table.add_columns(f"(no {label.lower()} activity on this date)")
+            self._set_status(f"{service_type} — {date}  ·  no data{note_suffix}  ·  Esc to return")
+            return
+        total = float(df["CREDITS"].sum())
+        max_c = float(df["CREDITS"].max()) if total > 0 else 1.0
+        has_requests = "REQUEST_COUNT" in df.columns
+        if has_requests:
+            table.add_columns(label.upper(), "CREDITS", "REQUESTS", "% OF SERVICE", "BAR")
+        else:
+            table.add_columns(label.upper(), "CREDITS", "% OF SERVICE", "BAR")
+        for _, row in df.iterrows():
+            credits = float(row["CREDITS"])
+            pct = (credits / total * 100) if total > 0 else 0
+            cells = [str(row["RESOURCE_NAME"]), f"{credits:,.4f}"]
+            if has_requests:
+                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"]))
+        user_hint = (
+            "  ·  click to see users"
+            if self._drill_day_resource_kind in ("warehouse", "ai")
+            else ""
+        )
+        self._set_status(
+            f"{service_type} — {date}  ·  {total:,.4f} credits{note_suffix}{user_hint}  ·  Esc to return"
+        )
+
+    # --- Drill: user breakdown (Level 3) -----------------------------
+
+    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._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)
+
+    @work(thread=True, exclusive=True, group="cost")
+    def _day_resource_users_worker(self, *, date: str, service_type: str, resource: str) -> None:
+        try:
+            df, note = self.app.get_cost_service().get_day_resource_users(
+                date, service_type, resource
+            )
+        except Exception as e:
+            self.app.call_from_thread(self._fetch_failed, e)
+            return
+        self.app.call_from_thread(self._render_day_resource_users, df, date, resource, note)
+
+    def _render_day_resource_users(self, df: pd.DataFrame, date: str,
+                                    resource: str, note: str | None) -> None:
+        self._reset_table()
+        table = self.query_one(DataTable)
+        note_suffix = f"  ·  ⚠ {note}" if note else ""
+        if note and "No user-level" in note:
+            table.add_columns("(no user-level detail available for this resource type)")
+            self._set_status(f"{resource} — {date}{note_suffix}  ·  Esc to return")
+            return
+        if df is None or df.empty:
+            table.add_columns("(no users found)")
+            self._set_status(f"{resource} — {date}  ·  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", "QUERIES", "% OF RESOURCE", "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),
+                key=str(row["USER_NAME"]),
+            )
+        query_hint = (
+            "  ·  click user to see top queries"
+            if self._drill_day_resource_kind == "warehouse"
+            else ""
+        )
+        self._set_status(
+            f"{resource} users — {date}  ·  {total:,.4f} credits{note_suffix}{query_hint}  ·  Esc to return"
+        )
+
+    # --- Drill: top queries for a user (Level 4) ----------------------
+
+    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._set_status(
+            f"Loading top queries for {user} on {warehouse} ({date})…  Esc to return"
+        )
+        self._day_user_queries_worker(date=date, warehouse=warehouse, user=user)
+
+    @work(thread=True, exclusive=True, group="cost")
+    def _day_user_queries_worker(self, *, date: str, warehouse: str, user: str) -> None:
+        try:
+            df, note = self.app.get_cost_service().get_day_user_queries(
+                date, warehouse, user, limit=3
+            )
+        except Exception as e:
+            self.app.call_from_thread(self._fetch_failed, e)
+            return
+        self.app.call_from_thread(self._render_day_user_queries, df, date, warehouse, user, note)
+
+    def _render_day_user_queries(self, df: pd.DataFrame, date: str,
+                                  warehouse: str, user: str, note: str | None) -> None:
+        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} on {warehouse} — {date}  ·  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"Day detail — {date}  ·  {total:,.4f} credits  ·  Esc to return"
+            f"Top queries — {user} on {warehouse} — {date}{note_suffix}"
+            f"  ·  ⏎ open in Tune  ·  Esc to return"
         )
 
     # --- View 6: AI services -----------------------------------------

{snowglobe_cli-0.2.1 → snowglobe_cli-0.2.3}/snowglobe_cli.egg-info/PKG-INFO

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