Notebook Gallery topics

Fabric Metadata & Data Quality Assessment Framework

thisismukund — Fri, 18 Sep 2026 02:31:34 GMT

Overview

A reusable Microsoft Fabric notebook for metadata discovery, single-pass PySpark data profiling, rule-based data quality assessment, and Data Quality Index (DQI) scoring.

Key Capabilities

Dual Execution Modes: Run on synthetic e-commerce data or target existing Delta tables in OneLake.

High-Performance Profiling: Single-pass PySpark aggregations compute distinct counts, null ratios, and boundaries in a single Spark action call.

Multi-Dimension Quality Auditing: Evaluates Completeness, Uniqueness, and Validity using custom weighted thresholds.

Executive Reporting: Generates an aggregate Data Quality Index (DQI) score and automated remediation guidance.

Use Cases

Lakehouse data quality monitoring and health checks
Data product readiness for Gold layer consumption
Pre- and post-migration validation
Enterprise data platform modernization

Full Notebook & Code: Download the complete .ipynb notebook file from the Github Repository

Fabric Data Agent Analyzer

farhansoomro — Fri, 28 Aug 2026 17:26:55 GMT

Fabric Data Agents are only as effective as the data foundation behind them. Following best practices is critical to achieving accurate, reliable, and consistent responses. This notebook automates the review process, helping you quickly identify optimization opportunities and improve AI readiness.

Direct Query Semantic Model BPA

farhansoomro — Fri, 28 Aug 2026 12:53:42 GMT

DirectQuery is often blamed for poor performance, but a well-designed DirectQuery semantic model can perform efficiently when best practices are followed. This notebook automates the review process, quickly identifying potential performance bottlenecks and optimization opportunities.

OneLake security data access role replication

baguena_raf — Thu, 03 Sep 2026 06:14:45 GMT

This Python notebook provides a basic example for OneLake security data access roles replication between different environments.

At the moment:

OneLake security roles are only deployed through Fabric deployment pipelines, which only covers the roles defined, not the actual Entra ID user/group member assignments (just permission group assignments).
On its latest version, fabric-cicd does not deploy OneLake security roles.

How it works:

Through the OneLake security REST APIs, we can take the existing role definition and assignments from a specific environment and replicate them to another entirely.

The example relies on two specific methods:

List Data Access Roles
Create Or Update Data Access Roles

This way, we can:

Persist/modify the already assigned Entra ID users and/or groups to the existing roles from one lakehouse to another.
Point the existing permission group assignments to the target (workspace + lakehouse).

Credentials for the whole process are provided through NotebookUtils.

⚠️IMPORTANT

The process, as it is, overwrites the existing roles and assignments at the target with the source's configuration. Any roles and/or assignments non declared at the source will be deleted.
The identity running the process must have at least the Member role in the referenced workspaces.
When running under a service principal, token management could require some adjustments, specially if the code does not run inside Fabric.

You can find the notebook here, feel free to adapt the code as needed. For example, once tweaked, it could be used as an step inside an ADO/GitHub pipeline and deploy the existing OneLake roles defined over each lakehouse while replicating the roles established and updating the user/group assignments depending on the deployment environment, complementing fabric-cicd deployments.

Another possible implementation can be done with Terraform. If interested in managing Fabric with Terraform, you can take a look at my GitHub repo.

Hope you find it useful!

Find Which Semantic Models Use a Specific Database Table — Across All Workspaces

SBegum — Fri, 31 Jul 2026 03:28:13 GMT

Ever needed to know which Power BI semantic models reference a specific source table before making a change or deprecating it?

This reusable Fabric Notebook scans all accessible workspaces in one run and identifies every semantic model that references your target table — no manual clicking required.

Key Features:
✅ Scans all workspaces in a single run
✅ Filter by workspace name keyword (e.g. [DEV] only)
✅ Three scan methods per model — datasources, model objects, and BIM/M query expressions
✅ Deduplicates results across scan methods
✅ Logs skipped models separately (permission errors)
✅ Export results to CSV in Lakehouse

Libraries used: semantic-link-labs, sempy.fabric

https%3A%2F%2Fgithub.com%2FBIWithSadia%2Fbi-toolkit%2Fblob%2Fmain%2FDB_table_across_all_workspaces.ipynb

Fabric Shortcut Inventory

kilianbs — Thu, 30 Jul 2026 13:59:31 GMT

A Microsoft Fabric notebook that scans workspaces and builds a complete inventory of OneLake shortcuts, detecting orphaned, circular and ungoverned external shortcuts, with an interactive HTML report and optional persistence to a Delta table.

Why?

OneLake shortcuts are easy to create and hard to govern: over time you accumulate shortcuts pointing to deleted items, circular chains between lakehouses, and connections to external storage (S3, ADLS, GCS…) with no sensitivity label or endorsement whatsoever. Fabric offers no centralized view of any of this. This notebook builds one in a single run.

What it does

Discovers workspaces — the entire tenant (with admin permissions) or a specific list, by name or ID.
Discovers items — lists the items in each workspace via the Fabric REST API.
Extracts shortcuts — in parallel, from the item types that support them (Lakehouse, KQL Database, Mirrored Database).
Parses targets — normalizes OneLake targets (workspace/item/path) and external ones (Amazon S3, ADLS Gen2, Google Cloud Storage, S3 compatible, Dataverse, Azure Blob Storage, OneDrive/SharePoint).
Validates:
- Orphaned: the target item no longer exists within the scanned scope.
- Circular: shortcut chains that form a cycle (DFS detection over the dependency graph).
- Governance: external shortcuts on items with no sensitivity label and no endorsement (Certified/Promoted).
Resolves names — turns target GUIDs into human-readable names, even for targets outside the scanned scope.
Presents — an interactive HTML report with 4 views (Overview, Circular, Orphan, Governance) and per-row color coding.
Persists (optional) — writes the inventory to a Delta table so you can query it with SQL or build Power BI reports on top

All the code and documentation can be found in the Github Repository.

https%3A%2F%2Fgithub.com%2Fkilianbs%2Ffabric-shortcut-inventory%2Fblob%2Fmain%2Fshortcut_inventory_en.ipynb

DP-600 Study Companion Notebook for Microsoft Fabric

sabledattatray — Thu, 25 Jun 2026 03:36:41 GMT

I created this study companion notebook while preparing for the DP-600: Implementing Analytics Solutions Using Microsoft Fabric certification.

The repository brings together key Microsoft Fabric concepts including OneLake, Lakehouse, Data Warehouse, Direct Lake, Semantic Models, DAX, Security, Governance, and Monitoring in a single reference guide.

The goal is to help analytics engineers, Power BI developers, and certification candidates understand Fabric architecture through practical notes, diagrams, and notebook-based examples.

Repository:
https://github.com/sabledattatray/dp600-study-companion-notebook

Feedback and suggestions are welcome. I hope this resource helps others on their Microsoft Fabric learning journey.

https%3A%2F%2Fgithub.com%2Fsabledattatray%2Fdp600-study-companion-notebook

Fabric Spark Pool Optimiser

eguigurene — Sun, 31 May 2026 16:39:03 GMT

Fabric Spark Pool Optimiser — right-size your Spark pools in 3 minutes

Every workspace in Microsoft Fabric gets the same default Spark pool. Medium node, up to 10 nodes. Nobody changes it — even in production, even when the actual workload is a 5,000-row dimension table or a monitoring notebook reading 0.002 GB.

This notebook analyses 7 days of real Spark session history across all your workspaces and tells you exactly which pools are oversized, undersized, or correctly sized — with a step-by-step configuration guide for each one.

What it does:

- Auto-discovers all workspaces you have access to

- Detects orchestrator workspaces automatically (runMultiple / Data Factory)

- Separates automated pipeline sessions from interactive dev sessions — dev sessions skew duration data and are excluded from the CU calculation

- Analyses GB read/written/shuffled via the Spark History stages API

- Estimates monthly CU savings based on real usage

- Renders an interactive dashboard directly in the notebook output

No lakehouse needed. No configuration. Just import and Run All.

Tested across two organisations. In one run: 50 workspaces analysed, 8 pools to change, 1,441 CU estimated monthly saving.

Feedback welcome — especially if you find API behaviour that differs in your environment.

https%3A%2F%2Fgithub.com%2Fenekoegiguren%2Ffabricsparkpooloptimiser

Fix Slicers with Custom Visual SLICERBAR

AlexanderKornMS — Fri, 29 May 2026 13:52:09 GMT

Fabric-Notebooks/Migrate Slicers to SLICERBAR.ipynb at main · KornAlexander/Fabric-Notebooks

Migrate Native Slicers → SLICERBAR

This notebook consolidates the native Power BI slicer visuals on a report page into a single SLICERBAR custom visual using the fix_migrate_slicer_to_slicerbar fixer from the PBI Fixer build of semantic-link-labs.

Purpose

Reports often accumulate many individual slicer visuals that clutter the canvas and consume real estate. The SLICERBAR custom visual collapses all of those filters into one compact, modern control. This fixer automates that migration directly against the report definition (PBIR) — no manual rebuilding required.

What it does

For the page you specify, the fixer:

Finds the SLICERBAR visual on the page. If none exists, it creates a narrow one in the top-right corner and registers the custom visual in the report.
Finds every native slicer visual on the page.
For each slicer, extracts its field (Entity + Property) and adds it to the Slicer Bar's query + configuration.
Skips duplicates (a field already present in the Slicer Bar) but still removes the redundant native slicer.
Deletes the original native slicers once migrated.

Requirements

The report must be in PBIR format. If it is in the legacy format, run Upgrade to PBIR first.
Use scan_only=True for a safe dry run before committing changes.

1. Install

Install the PBI Fixer build of semantic-link-labs. The PySpark kernel restarts automatically after install — that is expected. Run this once per session.

%pip install git+https://github.com/KornAlexander/semantic-link-labs.git@feature/pbi-fixer-ui -q

2. Import the fixer

from sempy_labs.report._Fix_MigrateSlicerToSlicerbar import fix_migrate_slicer_to_slicerbar

3. Dry run (recommended first)

scan_only=True reports exactly which slicers would be migrated — nothing is written to the report. Review the output before running the real migration.

fix_migrate_slicer_to_slicerbar(report="report name", page_name="page name", scan_only=True)

4. Run the migration

This applies the changes: it creates the Slicer Bar if missing, migrates the native slicers into it, and deletes the originals.

fix_migrate_slicer_to_slicerbar(report="report name", page_name="page name")

Parameters

Parameter Description

report	Name or ID of the report.
page_name	Display name of the page to migrate.
workspace	Workspace name or ID. Defaults to the attached lakehouse / notebook workspace.
scan_only	If True, only reports what would change without writing.

Notes

When no Slicer Bar exists on the page, a new one is placed top-right, 200 px wide, full page height, titled Slicers.
The SLICERBAR custom visual is registered in report.json automatically (idempotent).
Re-running on a page that already has all fields migrated simply removes any leftover duplicate native slicers.

https%3A%2F%2Fgithub.com%2FKornAlexander%2FFabric-Notebooks%2Fblob%2Fmain%2FMigrate%2520Slicers%2520to%2520SLICERBAR.ipynb

Get a list of Custom Visuals

AlexanderKornMS — Fri, 15 May 2026 08:16:29 GMT

The following two scripts check for custom visuals in use for the whole tenant and lists them.

Lightweight alternative for individual reports

This script checks for custom visuals in use for the whole tenant and lists them.

%pip install semantic-link-labs --quiet import sempy_labs as labs from sempy_labs.report import ReportWrapper cv = ReportWrapper(report="Report Name", workspace="Workspace Name").list_custom_visuals() display(cv)<p> </p><p>For all reports in current or all workspaces the following notebook works:<li-code lang="markup"># Custom Visuals Inventory across a Power BI / Fabric Workspace **Author:** Alexander Korn — Solution Engineer Data Platform, Microsoft **Last updated:** 2026-05-15 **Runtime:** Microsoft Fabric Notebook (Python) **Dependencies:** [`semantic-link-labs`](https://github.com/microsoft/semantic-link-labs) --- ## Purpose Governance teams frequently need to answer a deceptively simple question: > **Which custom (third-party / AppSource / organizational) visuals are actually used in our Power BI reports — and where?** This information is essential for: - **Tenant governance** — admins disabling or restricting custom visuals need an impact assessment first. - **Security & compliance** — custom visuals are arbitrary code; you should know what is in production. - **Lifecycle management** — identifying unused or deprecated visuals before cleanup. - **Migration planning** — moving reports between tenants or to Fabric requires knowing every visual dependency. ## What this notebook does It scans **every Power BI report in a given workspace** (or list of workspaces) and produces a tidy table: | Workspace | Report | Custom Visual Name | Custom Visual Display Name | |-----------|--------|--------------------|----------------------------| Under the hood it uses `sempy_labs.report.ReportWrapper.list_custom_visuals()` from semantic-link-labs, which parses the report definition (PBIR) and returns the visuals registered in the report. > ℹ️ Reports stored in the legacy single-file PBIX layout are skipped — see **Notes & limitations** at the bottom for how to convert them. ## How to use 1. Attach this notebook to any Lakehouse in your target workspace (no tables are written — the lakehouse attachment is only required by the Fabric Python runtime). 2. Run the install cell once per session (or bake `semantic-link-labs` into a custom Fabric environment). 3. Set `MODE` (and optionally `WORKSPACES`) in the configuration cell. 4. Run all cells. The final cell renders the inventory table and a few aggregations. --- ## 1. Install dependencies Run this once per Fabric session. To avoid the install on every run, add `semantic-link-labs` to a [custom Fabric environment](https://learn.microsoft.com/fabric/data-engineering/create-and-use-environment) and attach it to the notebook. %pip install semantic-link-labs --quiet ## 2. Configuration Pick the **scan mode**: - `"current"` — scan only the workspace this notebook is attached to. - `"list"` — scan the workspaces named in `WORKSPACES`. - `"all"` — scan every workspace the executing identity can see (slow on large tenants). # Scan mode: "current" | "list" | "all" MODE = "current" # Used only when MODE == "list" — workspace names or IDs. WORKSPACES: list[str] = ["Demo"] ## 3. The function `list_custom_visuals_in_workspace(workspace)` returns a tidy DataFrame with one row per (report, custom visual) pair. It silently skips paginated reports and any report it can't parse, logging the reason. import traceback import pandas as pd import sempy.fabric as fabric from sempy_labs.report import ReportWrapper def _resolve_workspace(workspace: str | None) -> str: """Resolve workspace name — fall back to the notebook's current workspace.""" if workspace: return workspace ws_id = fabric.get_notebook_workspace_id() return fabric.resolve_workspace_name(ws_id) def list_custom_visuals_in_workspace(workspace: str | None = None) -> pd.DataFrame: """Return all custom visuals used by Power BI reports in a workspace. Columns: Workspace, Report, Custom Visual Name, Custom Visual Display Name. """ ws = _resolve_workspace(workspace) try: reports = fabric.list_reports(workspace=ws) except Exception: print(f" · could not list reports in '{ws}':") traceback.print_exc() return pd.DataFrame(columns=["Workspace", "Report", "Custom Visual Name", "Custom Visual Display Name"]) type_col = "Report Type" if "Report Type" in reports.columns else None if type_col: reports = reports[reports[type_col].isin(["PowerBIReport", "Power BI Report"])] name_col = "Name" if "Name" in reports.columns else "Report Name" rows = [] for _, r in reports.iterrows(): report_name = r[name_col] try: rw = ReportWrapper(report=report_name, workspace=ws) cv = rw.list_custom_visuals() except Exception as e: print(f" · skipping '{report_name}': {type(e).__name__}: {e}") continue if cv is None or cv.empty: continue used_col = next((c for c in cv.columns if c.lower().startswith("used")), None) used = cv[cv[used_col] == True] if used_col else cv # noqa: E712 for _, v in used.iterrows(): rows.append({ "Workspace": ws, "Report": report_name, "Custom Visual Name": v.get("Custom Visual Name"), "Custom Visual Display Name": v.get("Custom Visual Display Name"), }) return pd.DataFrame( rows, columns=["Workspace", "Report", "Custom Visual Name", "Custom Visual Display Name"], ) def list_custom_visuals_multi(workspaces: list[str | None]) -> pd.DataFrame: """Run the inventory across multiple workspaces and concatenate the results.""" frames = [] for ws in workspaces: print(f"Scanning workspace: {ws or '<current>'}") frames.append(list_custom_visuals_in_workspace(ws)) return pd.concat(frames, ignore_index=True) if frames else pd.DataFrame() ## 4. Report format inventory (PBIR vs. PBIRLegacy) Lists every Power BI report in the configured workspace(s) along with its **storage format** (`PBIR` or `PBIRLegacy`). Reports flagged as `PBIRLegacy` will be skipped by the custom-visuals scan in section 5. This uses the Power BI REST API `format` field directly — the same signal that [`sempy_labs.report.upgrade_to_pbir`](https://semantic-link-labs.readthedocs.io/en/stable/sempy_labs.report.html) reads. To actually upgrade, see the tip at the bottom of the cell. The same `MODE` / `WORKSPACES` configuration applies. from sempy.fabric import FabricRestClient _client = FabricRestClient() def list_report_formats(workspace: str | None = None) -> pd.DataFrame: """List Workspace, Report, Format ('PBIR' / 'PBIRLegacy') for every PBI report. Uses the Power BI REST API `format` field — same signal that ``sempy_labs.report.upgrade_to_pbir`` relies on, but read-only. """ ws_name = _resolve_workspace(workspace) ws_id = fabric.resolve_workspace_id(ws_name) resp = _client.get(f"/v1.0/myorg/groups/{ws_id}/reports").json() rows = [ {"Workspace": ws_name, "Report": r["name"], "Format": r.get("format", "Unknown")} for r in resp.get("value", []) if r.get("reportType") in (None, "PowerBIReport") ] return pd.DataFrame(rows, columns=["Workspace", "Report", "Format"]) # Reuse the same MODE / WORKSPACES configuration as the rest of the notebook. def _targets_from_config() -> list[str | None]: if MODE == "current": return [None] if MODE == "list": return list(WORKSPACES) if MODE == "all": all_ws = fabric.list_workspaces() if "Type" in all_ws.columns: all_ws = all_ws[all_ws["Type"] == "Workspace"] name_col = "Name" if "Name" in all_ws.columns else "Workspace Name" return all_ws[name_col].tolist() raise ValueError(f"Unknown MODE '{MODE}'.") formats = pd.concat( [list_report_formats(ws) for ws in _targets_from_config()], ignore_index=True, ) if formats.empty: print("No Power BI reports found.") else: counts = formats["Format"].value_counts().to_dict() print("Report format summary — " + ", ".join(f"{k}: {v}" for k, v in counts.items())) display(formats) # Tip: to convert all PBIRLegacy reports automatically, run: # import sempy_labs as labs # labs.report.upgrade_to_pbir(workspace="Demo") ## 5. Run the inventory Resolves the workspace list from `MODE` and runs the scan. The result is always stored in `df`. def _resolve_workspace_list(mode: str, workspaces: list[str]) -> list[str | None]: """Translate MODE + WORKSPACES into the actual list of workspaces to scan.""" if mode == "current": return [None] if mode == "list": if not workspaces: raise ValueError("MODE='list' requires at least one entry in WORKSPACES.") return list(workspaces) if mode == "all": all_ws = fabric.list_workspaces() if "Type" in all_ws.columns: all_ws = all_ws[all_ws["Type"] == "Workspace"] name_col = "Name" if "Name" in all_ws.columns else "Workspace Name" return all_ws[name_col].tolist() raise ValueError(f"Unknown MODE '{mode}'. Use 'current', 'list', or 'all'.") targets = _resolve_workspace_list(MODE, WORKSPACES) print(f"MODE='{MODE}' → scanning {len(targets)} workspace(s).\n") df = list_custom_visuals_multi(targets) if df.empty: print("\nNo custom visuals found.") else: print(f"\nFound {len(df)} (report, custom visual) pairs across {df['Workspace'].nunique()} workspace(s) and {df['Report'].nunique()} report(s).") display(df) ## 6. Quick aggregations A few common slices the governance team typically wants right after the raw list. if not df.empty: # Most-used custom visuals top_visuals = ( df.groupby("Custom Visual Display Name") .agg(Reports=("Report", "nunique"), Workspaces=("Workspace", "nunique")) .sort_values("Reports", ascending=False) .reset_index() ) display(top_visuals) # Reports with the most custom visuals heavy_reports = ( df.groupby(["Workspace", "Report"]) .agg(CustomVisuals=("Custom Visual Display Name", "nunique")) .sort_values("CustomVisuals", ascending=False) .reset_index() ) display(heavy_reports) else: print("No data to aggregate — result set is empty.") --- ## Notes & limitations ### Reports must be stored in PBIR format This notebook reads each report's enhanced report definition (PBIR / `definition.pbir`) via the Fabric REST API. Reports still stored in the legacy single-file PBIX layout cannot be parsed by `ReportWrapper` — they are flagged as `Legacy (PBIX)` in section 4 and **skipped with a `NotImplementedError`** in section 5. **Two ways to convert a report to PBIR:** - **Power BI Service (Edit in browser)** — open the report in the service, click **Edit**, make any tiny change (or none), and **Save**. The service automatically rewrites the report to PBIR on save. Often the fastest option for bulk conversion. - **Power BI Desktop** — open the report, enable **File → Options → Preview features → "Power BI Project (.pbip) save format"** and **"Store reports using enhanced report format (PBIR)"**, then republish. PBIR is the default for any report authored natively in Fabric. ### Other notes - Only **Power BI reports** are inspected — paginated reports are skipped automatically. - Detection relies on visuals registered in the report's `definition.pbir`. A visual that is registered but not placed on a page can still appear; the `Used in Report` flag from semantic-link-labs is honoured when present. - Requires the executing identity to have at least **Viewer** role on every workspace it scans. - semantic-link-labs is an open-source community project maintained by Microsoft engineers — column names may evolve between releases. Pin a version in your custom Fabric environment for production use. ## License MIT — feel free to adapt and reuse.

https%3A%2F%2Fgithub.com%2FKornAlexander%2FPBI-Tools%2Fblob%2Fmain%2FNotebook%2520Gallery%2FCustom%2520Visuals%2520Inventory.ipynb

Usage Metrics Snapshot — Unlimited Power BI Usage History

AlexanderKornMS — Tue, 12 May 2026 14:50:25 GMT

Snapshot the hidden Report Usage Metrics Model semantic model into Lakehouse Delta tables via XMLA / sempy.evaluate_dax. Six append-only tables (Views, Reports, Users, Dates, DistributionMethods, Platforms), one SnapshotUtc column for deduplication, optional retention. Schedule daily after 04:00 UTC and you've broken Power BI's 30-day usage history wall — forever.

Requires: Premium / PPU / Fabric capacity, attached Lakehouse, tenant setting "Usage metrics for content creators" enabled.

# Usage Metrics Snapshot Snapshot the hidden **Report Usage Metrics Model** semantic model into Lakehouse Delta tables for **unlimited history**. ## Why Power BI's built-in usage metrics dataset only retains **30 days** of activity (rolling window). By querying it daily over XMLA via `sempy` and appending the rows to Lakehouse tables, we accumulate full history we control. ## Prerequisites - Workspace on Premium / PPU / Fabric capacity (XMLA endpoint enabled). - The `Report Usage Metrics Model` dataset exists in the workspace. It is auto-created the first time anyone clicks *More options → View usage metrics report* on a report. - A Lakehouse attached to this notebook (any Lakehouse in the workspace). - Tenant setting *“Usage metrics for content creators”* enabled. ## How to operate 1. Set `WORKSPACE_ID` below. 2. Run all cells once to verify. 3. Schedule the notebook **daily after 04:00 UTC** (the source refreshes around 03:00 UTC). ## What lands in the Lakehouse One Delta table per source table, prefixed `usage_metrics_*`, with an extra `SnapshotUtc` column. Append-only. | Source table | Lakehouse table | Role | |----------------------|---------------------------------------|---------------| | `Views` | `usage_metrics_views` | Fact | | `Reports` | `usage_metrics_reports` | Dimension | | `Users` | `usage_metrics_users` | Dimension | | `Dates` | `usage_metrics_dates` | Dimension | | `DistributionMethods`| `usage_metrics_distributionmethods` | Dimension | | `Platforms` | `usage_metrics_platforms` | Dimension | ## 1. Configuration import sempy.fabric as fabric from datetime import datetime, timezone, timedelta # ---- EDIT ME -------------------------------------------------------------- WORKSPACE_ID = "<your-workspace-guid>" # e.g., da2e15a8-c06d-4da0-ad10-c68aba63e564 DATASET_NAME = "Report Usage Metrics Model" TABLES = [ "Views", # fact "Reports", # dimensions "Users", "Dates", "DistributionMethods", "Platforms", ] # How many days of snapshots to keep (set to None to keep forever) RETENTION_DAYS = 400 # --------------------------------------------------------------------------- snap_ts = datetime.now(timezone.utc) print(f"Snapshot timestamp: {snap_ts.isoformat()}") ## 2. Snapshot all tables Each table is pulled with `EVALUATE 'TableName'` (full table scan). Column names are cleaned up (DAX returns them as `'Table'[Column]`). The result is appended to the corresponding Lakehouse Delta table with `mergeSchema=true` so new columns added by Microsoft over time are tolerated. results = [] for t in TABLES: df = fabric.evaluate_dax( dataset=DATASET_NAME, workspace=WORKSPACE_ID, dax_string=f"EVALUATE '{t}'", ) # Strip table name prefix from column names (DAX returns "TableName[Column]") df.columns = [c.split("[")[-1].rstrip("]") if "[" in c else c for c in df.columns] df["SnapshotUtc"] = snap_ts.isoformat() table_name = f"usage_metrics_{t.lower()}" sdf = spark.createDataFrame(df) (sdf.write .mode("append") .option("mergeSchema", "true") .saveAsTable(table_name)) results.append((t, table_name, len(df))) print(f" {t:25s} -> {table_name:40s} {len(df):>8} rows") print("\nDone.") ## 3. Retention (optional) Trim snapshots older than `RETENTION_DAYS` so the tables don't grow forever. Default 400 days ≈ 13 months — enough for YoY comparisons. if RETENTION_DAYS: cutoff = (snap_ts - timedelta(days=RETENTION_DAYS)).isoformat() for _, table_name, _ in results: spark.sql(f"DELETE FROM {table_name} WHERE SnapshotUtc < '{cutoff}'") print(f" Trimmed {table_name} (< {cutoff})") else: print("Retention disabled — keeping all snapshots.") --- # Verification & query examples The cells below are **not part of the daily job** — use them to verify the snapshot worked and to demo how to query the historical data. ## 4. Snapshot health check for _, table_name, _ in results: df = spark.sql(f""" SELECT '{table_name}' AS table_name, COUNT(*) AS total_rows, COUNT(DISTINCT SnapshotUtc) AS snapshot_count, MIN(SnapshotUtc) AS first_snapshot, MAX(SnapshotUtc) AS latest_snapshot FROM {table_name} """) df.show(truncate=False) ## 5. Peek at the latest snapshot of `Views` display(spark.sql(""" WITH latest AS ( SELECT MAX(SnapshotUtc) AS ts FROM usage_metrics_views ) SELECT v.* FROM usage_metrics_views v JOIN latest ON v.SnapshotUtc = latest.ts LIMIT 20 """)) ## 6. Daily views per report (full history) De-duplication pattern: take the **latest snapshot per natural key** so overlapping 30-day windows don't double-count. Adjust the `PARTITION BY` columns to whatever the real key columns are in your `Views` table (inspect with the previous cell). display(spark.sql(""" WITH ranked AS ( SELECT v.*, ROW_NUMBER() OVER ( PARTITION BY Date, ReportGuid, UserGuid ORDER BY SnapshotUtc DESC ) AS rn FROM usage_metrics_views v ) SELECT Date, ReportGuid, COUNT(*) AS views, COUNT(DISTINCT UserGuid) AS distinct_users FROM ranked WHERE rn = 1 GROUP BY Date, ReportGuid ORDER BY Date DESC, views DESC """)) ## 7. Top reports last 30 days (joined to `Reports` dim) display(spark.sql(""" WITH ranked_views AS ( SELECT v.*, ROW_NUMBER() OVER ( PARTITION BY Date, ReportGuid, UserGuid ORDER BY SnapshotUtc DESC ) AS rn FROM usage_metrics_views v ), latest_reports AS ( SELECT r.*, ROW_NUMBER() OVER ( PARTITION BY ReportGuid ORDER BY SnapshotUtc DESC ) AS rn FROM usage_metrics_reports r ) SELECT r.DisplayName, COUNT(*) AS views, COUNT(DISTINCT v.UserGuid) AS distinct_users FROM ranked_views v LEFT JOIN latest_reports r ON r.ReportGuid = v.ReportGuid AND r.rn = 1 WHERE v.rn = 1 AND v.Date >= date_sub(current_date(), 30) GROUP BY r.DisplayName ORDER BY views DESC """))

https%3A%2F%2Fgithub.com%2FKornAlexander%2FPBI-Tools%2Fblob%2Fmain%2FNotebook%2520Gallery%2FUsage%2520Metrics%2520Snapshot.ipynb

Semantic Link - Semantic Model Chaos Lab

FLTHIBAU — Mon, 27 Apr 2026 08:02:52 GMT

# Semantic Link - Semantic Model Chaos Lab

Semantic Model Chaos Lab brings chaos engineering to Fabric semantic models. It uses Semantic Link to create a lightweight digital twin of a selected semantic model: metadata, measures, relationships, roles, Copilot readiness signals, and baseline DAX checks.

The notebook then simulates realistic schema, relationship, DAX, metadata, and security changes against that model twin to measure blast radius before deployment. The generated release gate report shows broken measures, value drift, impacted model objects, security role risk, Copilot readiness degradation, and suggested remediation.

The result is a reusable developer tool that helps BI teams prevent semantic model incidents before they reach production.

Note: I realize the official submission deadline has passed, but I wanted to share this as a late community showcase because the idea explores a different angle for Semantic Link: model twins, chaos engineering, and release gates for semantic models.

https%3A%2F%2Fgithub.com%2Fflthibau%2Fsemantic-model-chaos-lab%2Fblob%2Fmain%2F2026_SemanticLink_flthibau_SemanticModelChaosLab.ipynb

Semantic Model Version Control & Change Diff

Praful_Potphode — Mon, 20 Apr 2026 17:44:35 GMT

Power BI's built-in version history is UI-only — capped at 5 snapshots,14-day retention, and zero API access. Enterprise teams have no programmatic way to list, compare, or audit model changes.This notebook bridges that gap using Semantic Link (SemPy) and Microsoft Fabric. It captures point-in-time snapshots of all five semantic model artifact types — Measures, Columns, Relationships, Tables, and RLS Roles — and persists them as Delta tables in OneLake via Apache Spark. A field-level
diff engine then compares any two run IDs and classifies every change as ADDED, REMOVED, or MODIFIED with before/after values.

Key capabilities:

Dual-path extraction: fabric.list_*() API with automatic DMV fallback.
Unlimited history beyond the built-in 5-version / 14-day limit.
Field-level diff across all artifact types including DAX expressions.
RLS role and membership change detection for security auditing.
Interactive ipywidgets UI with Fabric-branded HTML output.
Delta append mode — queryable directly from Power BI reports.
Schedulable via Fabric Data Pipeline for automated daily governance

Built entirely within Microsoft Fabric using sempy.fabric, sempy_labs,
PySpark, Delta Lake, and ipywidgets. No external tools or services required.

Github-https://github.com/praful-potphode/Fabric-Semantic-Link-Competition-2026

LinkedIn-https://www.linkedin.com/in/praful-p-912349241/

Community Profile-https://community.fabric.microsoft.com/t5/user/viewprofilepage/user-id/1261729

https%3A%2F%2Fgithub.com%2Fpraful-potphode%2FFabric-Semantic-Link-Competition-2026

Semantic Link – MetaData Extractor

NandanHegde — Mon, 20 Apr 2026 17:13:05 GMT

📘 Notebook Description

The notebook is designed to extract, enrich, and visualize semantic model metadata and measure-level dependencies within Microsoft Fabric. It connects to a specified semantic model, retrieves tables, columns, measures, and relationships, and enhances measures with AI-generated business descriptions. The notebook then derives measure-to-measure dependencies from DAX expressions, builds a Directed Acyclic Graph (DAG), and presents both tabular lineage outputs and graph-based visualizations. This enables a deep understanding of how calculations are structured and interrelated within the semantic model.

🌟 Benefits

Measure Lineage Transparency: Provides clear visibility into how measures are built on top of one another, improving model understanding and governance.

AI-Powered Documentation: Automatically generates business-friendly descriptions for DAX measures, reducing manual documentation effort.

Impact Analysis: Identifies upstream and downstream dependencies between measures, helping assess the impact of logic changes

GitHub URL : https://github.com/NandanHegde15/MSFTFabric-Notebook/blob/main/SemanticModel/Metadata%20Extraction/2026_SemanticLink_NandanHegde_MetadataExtractor.ipynb

https%3A%2F%2Fgithub.com%2FNandanHegde15%2FMSFTFabric-Notebook%2Fblob%2Fmain%2FSemanticModel%2FMetadata%2520Extraction%2F2026_SemanticLink_NandanHegde_MetadataExtractor.ipynb

Semantic Link – DAXLoadTest

tharunkumarRTK — Mon, 20 Apr 2026 12:21:47 GMT

Every semantic-model developer asks the same question before a deploy: "will this regress under real user load?" Today there's no answer, Power BI teams either hand-write synthetic DAX or skip load-testing entirely.

DAXLoadTest replays the real DAX queries your users have been running against your semantic model, under configurable concurrency, and pinpoints which queries slow down — then tells you the exact Report → Page → Visualresponsible for each regression.

The tool combines three Fabric capabilities that have never been stitched together before:

Workspace Monitoring Eventhouse as the query corpus, the only source of historical DAX text in Fabric
sempy.fabric.evaluate_dax for parallel replay, with a novel DAX-VAR-literal tagging trick that survives XMLA normalization and gives a bulletproof join key between sent queries and trace logs
sempy_labs.report.ReportWrapper to auto-map VisualId GUIDs to human-readable report/page/visual names
Results land in an interactive Plotly dashboard (KPI tiles, regression bar chart, baseline-vs-load scatter, drill-down table) rendered inline. No Lakehouse, no Delta tables, no setup, set 4 parameters, run the notebook, read the dashboard. Drop it into a Data Factory pipeline to catch performance regressions before they reach users.

External libraries used:

semantic-link-labs (sempy_labs) — Microsoft's extension library. Used for sempy_labs.report.ReportWrapper.list_visuals() to enrich queries with Report → Page → Visual metadata. Repo: github.com/microsoft/semantic-link-labs
plotly — interactive dashboard rendering (KPI indicators, bar chart, log-log scatter, drill-down table).
pandas / numpy — in-memory analytics and join orchestration (pre-installed).
PySpark + Azure Data Explorer Spark connector (com.microsoft.kusto.spark.synapse.datasource) — pre-installed on Fabric; used to query the Workspace Monitoring Eventhouse via KQL.

Github Repo Link: Semantic Link - DAXLoadTest

https%3A%2F%2Fgithub.com%2Ftharunkumarr98%2FsemanticLinkChallenge2026%2Fblob%2Fmain%2F2026_SemanticLink_tharunkumarr98_DAXLoadTest.ipynb

Semantic Link – Moodle LMS Analytics & Model Governance Toolkit

techies — Sun, 19 Apr 2026 17:27:47 GMT

This notebook delivers a reusable Moodle LMS analytics and governance toolkit built entirely in Microsoft Fabric using Semantic Link Labs. It connects a real Moodle MySQL database through a Bronze-Silver Medallion Architecture, creates a Direct Lake semantic model with 31 measures across 8 folders, and uses sempy_labs for BPA, Vertipaq analysis, Hindi translation, and automated model refresh. Unique developer tools include DAX unit testing, DAX vs Silver data validation, model snapshot & diff, and custom Moodle-specific BPA rules.

Link to GitHub URL- MoodleLMSToolkit

https%3A%2F%2Fgithub.com%2Fcseprs%2FMoodleLMSToolkit

Semantic Link - Model Health & Security Suite

Natarajan_M — Sun, 19 Apr 2026 17:51:14 GMT

One notebook. 13 tools. Zero guesswork.

A comprehensive diagnostic, remediation, and security auditing toolkit for Microsoft Fabric semantic models — delivered as a single self-contained Fabric notebook with an interactive ipywidgets console. Scans any Import / Direct Lake / DirectQuery model, produces a full HTML dashboard with scores and findings, and auto-applies fixes via TOM writes.

Three features in this notebook solve problems that no existing Fabric or Power BI tool addresses end-to-end:

🔒 Security X-Ray — Effective Access Map

Enterprise Power BI security is managed through Azure AD groups, not individual users. An AD group assigned to an RLS role might contain 200 users, nested sub-groups, and service principals. Until now there was no tool, no REST API, no sempy function that answered:

"Given all the RLS filters, OLS restrictions, AD group memberships, and workspace roles — what does each real human actually see?"

Security X-Ray combines TOM + DAX INFO.ROLES() + Microsoft Graph /transitiveMembers + Fabric REST roleAssignments into a single Effective Access Map that flags the critical blind spot: users who bypass RLS via workspace Admin/Member/Contributor privileges — a silent risk the standard Power BI UI never surfaces.

🤖 AI Generation — Schema-Aware Descriptions at Scale

Writing meaningful descriptions, synonyms, and AI instructions across hundreds of tables, columns, and measures is impractical by hand. Generic AI prompts miss business context and produce bland, interchangeable text that weakens Copilot quality. Bringing rich schema context into AI generation from inside a Fabric notebook hasn't been possible — until now.

"How do I make every measure, column, and table in my model Copilot-ready with descriptions, synonyms, and AI instructions that actually reflect my business — without writing them all by hand?"

AI Generation combines Azure OpenAI via Fabric Copilot auth (no API key, no endpoint config — just synapse.ml.fabric.credentials.get_openai_httpx_sync_client()) with full schema context injection: relationships, data types, DAX expressions, and user-supplied business domain. Every generated description is grounded in the actual model, not hallucinated. Reviewable plan before any TOM write, with graceful fallback to rule-based templates when AI is unavailable.

🔄 Model Diff — Cross-Workspace Drift Detection

Semantic models live across multiple workspaces — dev, test, UAT, prod, client A, client B. There is no built-in Fabric tool that compares two models to answer "what changed?" Drift happens silently: someone adds a measure in dev, tweaks a DAX formula in prod, removes a column during a refactor — and these changes go unnoticed until a report breaks.

"What changed between my dev model and my prod model? Which tables, columns, or measures were added, removed, or modified — and are any DAX expressions different?"

Model Diff uses sempy TOM reads across two workspaces + tabular schema comparison + DAX expression normalization to produce a structured drift report covering tables, columns, measures, relationships, and DAX changes. Essential for DataOps / release workflows and multi-tenant engagements where models live in many places.

🎯 13 Tools In One Scan

Copilot Readiness — descriptions, synonyms, hidden keys, format strings, AI Prep
Lineage — measure → source, blast radius, unused columns, dead code
Test Framework — every DAX measure evaluated, relationships validated
Model Diff — compare across workspaces (dev vs prod drift)
Report Visuals — broken refs, unused measures (model-filtered)
Security Audit — role compliance, RLS/OLS coverage
Security X-Ray — effective access + workspace bypass detection
Data Quality — referential integrity, null-rate (batched DAX UNION, 10× faster)
DAX Dependencies — fan-in/fan-out, circular references
sempy_labs integrations — BPA, Vertipaq, Direct Lake, Capacity (opt-in)

⚙️ Auto-Fix 9 Categories Via TOM

Preview all generated fixes in a reviewable plan, then apply selected ones: AI/template descriptions, synonyms (Culture ObjectTranslation), hidden keys, format strings, summarize-by, model CustomInstructions, AI instructions, schema reduction (isAvailableInMDX + LinguisticMetadata Entity Visibility), role descriptions.

🏗️ Technical Highlights

Chunked HTML rendering — overcomes Fabric's ~100 KB displayHTML limit
SPN Graph token via MSAL — 0.3s vs 60s+ notebookutils.credentials hang
Azure OpenAI via Fabric auth — no API key needed
AAD group expansion — recursive /transitiveMembers with pagination
Scan log capture — contextlib.redirect_stdout keeps the config form visible
Demo Mode — sequential pseudonyms for safe public screenshots

🚀 Quick Start

Cell 1 (install) → Cell 2 (engine) → Cell 3 (console + Run Scan) → Cell 4 (scan log) → Cell 5 (dashboard) → Cell 6 (apply fixes).

Graceful degradation: works without SPN (skips Graph expansion), without Copilot (falls back to template descriptions), without Directory.Read.All (shows object GUIDs), and read-only mode if no write access.

📦 Complete Repo

GitHub — full repo, 37 screenshots, sample HTML dashboard, MIT license

Author: Natarajan Manivasagan
LinkedIn · Fabric Community Profile

https%3A%2F%2Fgithub.com%2FNatarajanManivasagan%2FFabric-Semantic-Link-Developer-Experience-Challenge-2026-Apr%2Fblob%2Fmain%2F2026_SemanticLink_NatarajanManivasagan_ModelHealthAndSecuritySuite.ipynb

Semantic Link: Playground

ssrithar — Sat, 18 Apr 2026 03:46:04 GMT

The problem

Semantic model developers constantly face "what if?" questions: What if I change this measure's formula? How much would the number move? Which downstream KPIs would be affected? Is it safe to make this change?

Today the only option is to edit the live model, evaluate, and revert. That's risky in production, slow in development, and impossible to do side-by-side. There's no "preview" button for DAX.

The solution

Playground gives you a safe sandbox for measure experimentation. It introduces four operations:

Explore reads every measure from the TMSL , evaluates each one at total level, and presents a searchable catalog with DAX expressions and current values.

What-If. evaluates both the original and your modified DAX side-by-side using overrides in . The live model definition is never touched. Supports optional dimensional breakdowns via .

Impact finds every downstream measure that references the one you changed (via regex-based DAX dependency parsing), re-evaluates each with your override injected, and reports the full cascade of value changes.

Compare evaluates multiple alternative formulas for the same measure in a single call, rendering a comparison table and chart.

Why this advances developer experience

Every other tool in the Semantic Link ecosystem is read-only — it inspects, validates, diffs, or documents the model as it is. Playground is the only tool that lets you safely change a measure and see what happens, without committing to the live model. It fills the gap between "I have an idea for a formula change" and "I'm confident enough to deploy it."

https://github.com/ssritharsajitha/Semantic-Link-Playground

https%3A%2F%2Fgithub.com%2Fssritharsajitha%2FSemantic-Link-Playground

Semantic Link – Semantic Radar

Christian_To — Fri, 17 Apr 2026 20:22:08 GMT

The notebook scans semantic models using either service principal or current-user access, analyzes datasource and metadata patterns, identifies duplicate or overlapping models, and turns the findings into actionable governance outputs for administrators and data owners.

Capabilities:

Semantic Model Discovery: Scans semantic models across Microsoft Fabric workspaces and capacities, with support for admin APIs, workspace-level access, and optional workspace targeting.

Duplicate Source Detection: Identifies semantic models that connect to the same normalized datasource and highlights consolidation opportunities to promote shared semantic layers and reduce redundant logic.

Probable Overlap Detection: Detects likely duplicate or overlapping semantic models by comparing entities, columns, and metadata, even when datasource metadata is incomplete.

Actionable Governance Outputs: Produces prioritized action plans, executive summaries, responsibility views, diagnostics, and compact visual tables that help teams focus on the most important governance decisions.

Ownership and Collaboration Support: Maps impacted semantic models to dataset owners and workspace admins, and generates email drafts to accelerate review, coordination, and remediation.

Noise Reduction and Flexibility: Supports exclusions for intentional duplicates, sandbox models, and workspace-specific exceptions, while suppressing likely deployment clones to reduce false positives.

Microsoft Fabric-Native Experience: Designed as a Fabric notebook solution with visual-first output, configurable execution modes, and optional SemPy enrichment for deeper semantic model metadata.

Business value:
This solution helps data teams improve governance, reduce duplication, strengthen semantic model reuse, and create a clearer path toward centralized, maintainable, and trusted analytics assets in Microsoft Fabric.

All code and documentation can be found in the GitHub repository

https%3A%2F%2Fgithub.com%2Fchristiantodte%2FSemanticRadar

Semantic Link - Semantic Radar

Christian_To — Fri, 17 Apr 2026 20:15:02 GMT

This solution presents an automated governance framework for Microsoft Fabric semantic models that helps organizations detect duplication, reduce semantic model sprawl, and improve reuse across workspaces and capacities. The notebook scans semantic models using either service principal or current-user access, analyzes datasource and metadata patterns, identifies duplicate or overlapping models, and turns the findings into actionable governance outputs for administrators and data owners.

Capabilities:

Semantic Model Discovery: Scans semantic models across Microsoft Fabric workspaces and capacities, with support for admin APIs, workspace-level access, and optional workspace targeting.

Probable Overlap Detection: Detects likely duplicate or overlapping semantic models by comparing entities, columns, and metadata, even when datasource metadata is incomplete.

Actionable Governance Outputs: Produces prioritized action plans, executive summaries, responsibility views, diagnostics, and compact visual tables that help teams focus on the most important governance decisions.

Ownership and Collaboration Support: Maps impacted semantic models to dataset owners and workspace admins, and generates email drafts to accelerate review, coordination, and remediation.

Noise Reduction and Flexibility: Supports exclusions for intentional duplicates, sandbox models, and workspace-specific exceptions, while suppressing likely deployment clones to reduce false positives.

Microsoft Fabric-Native Experience: Designed as a Fabric notebook solution with visual-first output, configurable execution modes, and optional SemPy enrichment for deeper semantic model metadata.

Business value:
This solution helps data teams improve governance, reduce duplication, strengthen semantic model reuse, and create a clearer path toward centralized, maintainable, and trusted analytics assets in Microsoft Fabric.

All code and documentation can be found in the GitHub repository.

https%3A%2F%2Fgithub.com%2Fchristiantodte%2FSemanticRadar