Dashboard Expert

import mixpanel_headless as mp
from mixpanel_headless.types import (
    CreateDashboardParams,
    UpdateDashboardParams,
    UpdateTextCardParams,
    UpdateReportLinkParams,
    Dashboard,
)

ws = mp.Workspace()

params = CreateDashboardParams(
    title="Product Health Dashboard",
    description="Key metrics for monitoring product health.",
)

params = UpdateDashboardParams(title="Q1 Metrics v2")
data = params.model_dump(exclude_none=True)
# {"title": "Q1 Metrics v2"}

params = UpdateTextCardParams(markdown="<h2>Section Title</h2><p>Description.</p>")

params = UpdateReportLinkParams(link_type="embedded")
data = params.model_dump(by_alias=True, exclude_none=True)
# {"type": "embedded"}

def list_dashboards(self, *, ids: list[int] | None = None) -> list[Dashboard]

dashboards = ws.list_dashboards()
dashboards = ws.list_dashboards(ids=[101, 102, 103])

def create_dashboard(self, params: CreateDashboardParams) -> Dashboard

dashboard = ws.create_dashboard(CreateDashboardParams(title="Q1 Metrics"))
print(dashboard.id)  # Use this ID for all subsequent operations

def get_dashboard(self, dashboard_id: int) -> Dashboard

dash = ws.get_dashboard(dashboard_id)
# Access layout: dash.layout["order"], dash.layout["rows"]

def update_dashboard(self, dashboard_id: int, params: UpdateDashboardParams) -> Dashboard

# Metadata update
ws.update_dashboard(dashboard_id, UpdateDashboardParams(title="New Title"))

# Content action (see Section 2)
ws.update_dashboard(dashboard_id, UpdateDashboardParams(content={...}))

# Layout patch (see Section 3)
ws.update_dashboard(dashboard_id, UpdateDashboardParams(layout={...}))

def delete_dashboard(self, dashboard_id: int) -> None

def bulk_delete_dashboards(self, ids: list[int]) -> None

ws.bulk_delete_dashboards([101, 102, 103])

def favorite_dashboard(self, dashboard_id: int) -> None
def unfavorite_dashboard(self, dashboard_id: int) -> None

def pin_dashboard(self, dashboard_id: int) -> None
def unpin_dashboard(self, dashboard_id: int) -> None

def add_report_to_dashboard(self, dashboard_id: int, bookmark_id: int) -> Dashboard

updated_dash = ws.add_report_to_dashboard(dashboard_id, bookmark_id)

def remove_report_from_dashboard(self, dashboard_id: int, bookmark_id: int) -> Dashboard

ws.remove_report_from_dashboard(dashboard_id, report_id)

def update_text_card(self, dashboard_id: int, text_card_id: int, params: UpdateTextCardParams) -> None

ws.update_text_card(dashboard_id, text_card_id, UpdateTextCardParams(
    markdown="<h2>Updated Title</h2><p>New description.</p>"
))

def update_report_link(self, dashboard_id: int, report_link_id: int, params: UpdateReportLinkParams) -> None

ws.update_report_link(dashboard_id, report_link_id, UpdateReportLinkParams(link_type="embedded"))

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "create",
        "content_type": "text",
        "content_params": {
            "markdown": "<h2>Section Title</h2><p>Brief description of this section.</p>"
        },
    }
))

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "create",
        "content_type": "report",
        "content_params": {
            "source_bookmark_id": bookmark_id
        },
    }
))

import json

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "create",
        "content_type": "report",
        "content_params": {
            "bookmark": {
                "name": "Daily Active Users",
                "type": "insights",
                "params": json.dumps(result.params),
                "description": "DAU trend over the last 90 days.",
            }
        },
    }
))

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "delete",
        "content_type": "report",  # or "text"
        "content_id": content_id,
    }
))

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "update",
        "content_type": "text",
        "content_id": text_card_id,
        "content_params": {
            "markdown": "<h2>Updated Title</h2><p>New description.</p>"
        },
    }
))

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "duplicate",
        "content_type": "report",
        "content_id": content_id,
    }
))

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "undelete",
        "content_type": "report",
        "content_id": content_id,
    }
))

{
  "version": "2.0.0",
  "order": ["row-abc-123", "row-def-456"],
  "rows": {
    "row-abc-123": {
      "height": 0,
      "cells": [
        {
          "id": "cell-aaa-111",
          "width": 12,
          "content_id": 90001,
          "content_type": "text"
        }
      ]
    },
    "row-def-456": {
      "height": 336,
      "cells": [
        {
          "id": "cell-bbb-222",
          "width": 4,
          "content_id": 90002,
          "content_type": "report"
        },
        {
          "id": "cell-ccc-333",
          "width": 4,
          "content_id": 90003,
          "content_type": "report"
        },
        {
          "id": "cell-ddd-444",
          "width": 4,
          "content_id": 90004,
          "content_type": "report"
        }
      ]
    }
  }
}

{
  "rows_order": ["row-abc-123", "row-def-456"],
  "rows": [
    {
      "id": "row-abc-123",
      "height": 0,
      "cells": [
        {
          "id": "cell-aaa-111",
          "width": 12,
          "content_id": 90001,
          "content_type": "text"
        }
      ]
    },
    {
      "id": "row-def-456",
      "height": 418,
      "cells": [
        {
          "id": "cell-bbb-222",
          "width": 6,
          "content_id": 90002,
          "content_type": "report"
        },
        {
          "id": "cell-ccc-333",
          "width": 6,
          "content_id": 90003,
          "content_type": "report"
        }
      ]
    }
  ]
}

# 1. Get current layout to discover IDs
dash = ws.get_dashboard(dashboard_id)
layout = dash.layout  # dict with version, order, rows

# 2. Extract existing row/cell IDs and content IDs
# (IDs are auto-generated UUIDs; you must read them, not invent them)

# 3. Build the patch — rows_order (not order), rows as LIST (not dict)
row_ids = list(layout["order"])  # preserve current order, or rearrange
rows_list = []
for row_id in row_ids:
    row = layout["rows"][row_id]
    rows_list.append({
        "id": row_id,
        "height": row.get("height", 0),
        "cells": row.get("cells", []),
    })

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    layout={"rows_order": row_ids, "rows": rows_list}
))

markdown = (
    "<h2>Product Health Dashboard</h2>"
    "<p>Core metrics for monitoring product health. Updated daily.</p>"
)

markdown = (
    "<h2>Growth Trends</h2>"
    "<p>User acquisition and activation metrics over time.</p>"
)

markdown = (
    f"<p>^ DAU is <strong>{latest_dau:,.0f}</strong>, "
    f"{'up' if trend > 0 else 'down'} "
    f"<strong>{abs(trend):.1f}%</strong> vs. last week.</p>"
).replace("\n", "")

markdown = (
    "<p><em>Methodology:</em> DAU counts unique users who triggered "
    "any event in a calendar day. Excludes bot traffic.</p>"
)

markdown = (
    "<h3>Key Takeaway</h3>"
    "<p>Mobile conversion is <strong>2.3x higher</strong> than desktop. "
    "Prioritize mobile onboarding improvements.</p>"
)

markdown = (
    "<p><strong>Note:</strong> Data prior to Jan 15 reflects the old "
    "tracking schema. Direct comparison across that boundary is unreliable.</p>"
)

markdown = (
    "<h3>Q1 Highlights</h3>"
    "<ul>"
    "<li>DAU grew <strong>18%</strong> quarter-over-quarter</li>"
    "<li>Signup funnel conversion improved from 12% to 15%</li>"
    "<li>7-day retention stable at <strong>42%</strong></li>"
    "</ul>"
)

markdown = (
    "<blockquote>This dashboard covers the core product loop: "
    "acquisition, activation, retention. For revenue metrics, "
    "see the Revenue Dashboard.</blockquote>"
)

# Build multi-line for readability in code
markdown = (
    "<h2>Section Title</h2>"
    "<p>Description paragraph one.</p>"
    "<p>Description paragraph two.</p>"
)

# Strip newlines (critical -- TipTap mangles HTML with newlines)
clean_markdown = markdown.replace("\n", "")

# Send via content action
ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "create",
        "content_type": "text",
        "content_params": {"markdown": clean_markdown},
    }
))

# Or update existing text card directly
ws.update_text_card(dashboard_id, text_card_id, UpdateTextCardParams(
    markdown=clean_markdown
))

time_filter = {
    "dateRange": {
        "type": "in the last",
        "window": {"unit": "day", "value": 30}
    },
    "displayText": "Last 30 days"
}

dashboard = ws.create_dashboard(CreateDashboardParams(
    title="Rolling 30-Day Metrics",
    time_filter=time_filter,
))

time_filter = {
    "dateRange": {
        "type": "since",
        "from_date": "2025-01-01"
    },
    "displayText": "Since Jan 1, 2025"
}

dashboard = ws.create_dashboard(CreateDashboardParams(
    title="2025 Metrics",
    time_filter=time_filter,
))

time_filter = {
    "dateRange": {
        "type": "between",
        "from_date": "2025-01-01",
        "to": "2025-03-31"
    },
    "displayText": "Jan 1 - Mar 31, 2025"
}

dashboard = ws.create_dashboard(CreateDashboardParams(
    title="Q1 2025 Metrics",
    time_filter=time_filter,
))

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    time_filter={
        "dateRange": {
            "type": "in the last",
            "window": {"unit": "week", "value": 4}
        },
        "displayText": "Last 4 weeks"
    }
))

# Set to empty dict or None to remove dashboard-level time filter
ws.update_dashboard(dashboard_id, UpdateDashboardParams(time_filter={}))

# Read existing dashboard-level filters
dash = ws.get_dashboard(dashboard_id)
print(dash.filters)     # list of filter dicts, or None
print(dash.breakdowns)  # list of breakdown dicts, or None

# WRONG -- newlines in the string
markdown = "<h2>Title</h2>\n<p>Description</p>"

# CORRECT -- no newlines
markdown = "<h2>Title</h2><p>Description</p>"

# CORRECT -- use Python string concatenation for readability
markdown = (
    "<h2>Title</h2>"
    "<p>Description</p>"
)

duplicate = ws.create_dashboard(CreateDashboardParams(
    title="Product Health (Copy)",
    duplicate=existing_dashboard_id,
))

# Add to current user's favorites
ws.favorite_dashboard(dashboard_id)

# Remove from favorites
ws.unfavorite_dashboard(dashboard_id)

# Pin for all project members
ws.pin_dashboard(dashboard_id)

# Remove pin
ws.unpin_dashboard(dashboard_id)

import mixpanel_headless as mp
from mixpanel_headless.types import CreateDashboardParams, UpdateDashboardParams
import json

ws = mp.Workspace()

# 1. Create
dashboard = ws.create_dashboard(CreateDashboardParams(
    title="Weekly Product Review",
    description="Key metrics reviewed in the weekly product sync.",
    time_filter={
        "dateRange": {"type": "in the last", "window": {"unit": "day", "value": 7}},
        "displayText": "Last 7 days"
    },
))

# 2. Add content
ws.update_dashboard(dashboard.id, UpdateDashboardParams(
    content={"action": "create", "content_type": "text",
             "content_params": {"markdown": "<h2>Weekly Product Review</h2><p>Updated every Monday.</p>"}}))

result = ws.query("Login", from_date="2025-01-01", to_date="2025-03-31")
ws.update_dashboard(dashboard.id, UpdateDashboardParams(
    content={"action": "create", "content_type": "report",
             "content_params": {"bookmark": {"name": "DAU Trend", "type": "insights",
                                              "params": json.dumps(result.params)}}}))

# 3. Arrange layout (read IDs first)
dash = ws.get_dashboard(dashboard.id)
# ... build layout patch from dash.layout ...

# 4. Pin for the team
ws.pin_dashboard(dashboard.id)

# 5. Later: update title
ws.update_dashboard(dashboard.id, UpdateDashboardParams(
    title="Weekly Product Review (Q2 2025)"
))

# 6. Cleanup: delete when no longer needed
ws.delete_dashboard(dashboard.id)

import copy

dash = ws.get_dashboard(dashboard_id)
layout = copy.deepcopy(dash.layout)
target_row = layout["rows"][target_row_id]

# Redistribute widths: 12 / (N+1) for all cells including new
new_count = len(target_row["cells"]) + 1
cell_width = 12 // new_count
for cell in target_row["cells"]:
    cell["width"] = cell_width
target_row["cells"].append({"temp_id": "-1", "width": cell_width})

ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={
        "action": "create",
        "content_type": "report",
        "content_params": {
            "bookmark": {
                "name": "New Report",
                "type": "insights",
                "params": json.dumps(result.params),
            }
        },
    },
    layout={
        "rows_order": layout["order"],
        "rows": layout["rows"],
    },
))

before_rows = set(dash.layout["rows"].keys())
ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={"action": "create", "content_type": "text",
             "content_params": {"markdown": "<h2>New Section</h2>"}},
))
dash = ws.get_dashboard(dashboard_id)
after_rows = set(dash.layout["rows"].keys())
new_row_id = (after_rows - before_rows).pop()

# Delete old text card
ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={"action": "delete", "content_type": "text", "content_id": old_text_id},
))
# Create new report in its place
ws.update_dashboard(dashboard_id, UpdateDashboardParams(
    content={"action": "create", "content_type": "report",
             "content_params": {"bookmark": {...}}},
))

import json, re

dash = ws.get_dashboard(dashboard_id)
layout = dash.layout    # {"version": "2.0.0", "order": [...], "rows": {...}}
contents = dash.contents  # {"report": {...}, "text": {...}}

rows = []
for row_id in layout["order"]:
    row = layout["rows"][row_id]
    cells = []
    for cell in row["cells"]:
        cid = str(cell["content_id"])
        ctype = cell["content_type"]
        if ctype in ("report", "report-link"):
            info = contents["report"][cid]
            params = json.loads(info["params"]) if isinstance(info["params"], str) else (info.get("params") or {})
            cells.append({
                "type": ctype,
                "name": info.get("name", ""),
                "report_type": info.get("type", "insights"),
                "bookmark_id": info["id"],
                "description": info.get("description", ""),
                "width": cell["width"],
                "is_owned": ctype == "report",
                "params": params,
            })
        elif ctype == "text":
            md = contents["text"].get(cid, {}).get("markdown", "")
            cells.append({
                "type": "text",
                "markdown": md,
                "is_section_header": bool(re.search(r'<h2[\s>]', md, re.I)),
                "width": cell["width"],
            })
    rows.append({"row_id": row_id, "height": row.get("height", 0), "cells": cells})

is_section_header = bool(re.search(r'<h2[\s>]', markdown, re.I))

for row in rows:
    for cell in row["cells"]:
        if cell["type"] not in ("report", "report-link"):
            continue
        bid = cell["bookmark_id"]
        btype = cell["report_type"]
        if btype == "flows":
            result = ws.query_saved_flows(bid)
        else:
            result = ws.query_saved_report(bid, bookmark_type=btype)
        df = result.df
        # Summarize based on type:
        # insights: df.describe(), trend = df.iloc[-1] vs df.iloc[-8]
        # funnels: step conversion rates from result.series
        # retention: day-N rates from result.series

import pandas as pd

dashboard_ids = [1001, 1002, 1003]
all_reports = {}

for did in dashboard_ids:
    dash = ws.get_dashboard(did)
    for cid, info in dash.contents.get("report", {}).items():
        bid, btype = info["id"], info["type"]
        try:
            if btype == "flows":
                result = ws.query_saved_flows(bid)
            else:
                result = ws.query_saved_report(bid, bookmark_type=btype)
            all_reports[f"{dash.title} / {info['name']}"] = result.df
        except Exception as e:
            print(f"Skipping {info['name']}: {e}")

# Join on date index for cross-metric correlation
# combined = pd.concat([df1, df2], axis=1)
# correlation = combined.corr()