Fabric Metadata & Data Quality Assessment Framework
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 RepositoryOneLake security data access role replication
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!
Fabric Data Agent Analyzer
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.
Find Which Semantic Models Use a Specific Database Table — Across All Workspaces
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
Usage Metrics Snapshot — Unlimited Power BI Usage History
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.ipynbDP-600 Study Companion Notebook for Microsoft Fabric
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-notebookFabric Spark Pool Optimiser
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%2FfabricsparkpooloptimiserFix Slicers with Custom Visual SLICERBAR
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.ipynbGet a list of Custom Visuals
The following two scripts check for custom visuals in use for the whole tenant and lists them. Lightweight alternative for individual reports %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) 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
Semantic Link – Dataflow Gen1 to Gen2 Migration Assistant
Semantic Link – Dataflow Gen1 to Gen2 Migration Assistant is a reusable Fabric Notebook that helps developers safely modernize Power BI semantic models by detecting Dataflow Gen1 sources, mapping them to Dataflow Gen2 equivalents, updating the model BIM, creating a backup, rebinding the correct Fabric connection, refreshing the model, and validating the result. The tool follows a dry-run-first workflow to reduce manual edits, credential mistakes, and migration risk. Link Repooooooo!!: https://github.com/vicente2121/ChallengeSemantiklabs.git https%3A%2F%2Fgithub.com%2Fvicente2121%2FChallengeSemantiklabs%2Fblob%2Fac67250f4044e0db6d63b87a2fd84b36913e5089%2FSemantic%2520Link%2520%25E2%2580%2593%2520Dataflow%2520Gen1%2520to%2520Gen2%2520Migration%2520Assistant.ipynb
