semantic-link-labs 0.12.8__py3-none-any.whl

sempy_labs/report/_report_helper.py

@@ -0,0 +1,227 @@
+import requests
+import sempy_labs._icons as icons
+
+
+vis_type_mapping = {
+    "barChart": "Bar chart",
+    "columnChart": "Column chart",
+    "clusteredBarChart": "Clustered bar chart",
+    "clusteredColumnChart": "Clustered column chart",
+    "hundredPercentStackedBarChart": "100% Stacked bar chart",
+    "hundredPercentStackedColumnChart": "100% Stacked column chart",
+    "lineChart": "Line chart",
+    "areaChart": "Area chart",
+    "stackedAreaChart": "Stacked area chart",
+    "lineStackedColumnComboChart": "Line and stacked column chart",
+    "lineClusteredColumnComboChart": "Line and clustered column chart",
+    "ribbonChart": "Ribbon chart",
+    "waterfallChart": "Waterfall chart",
+    "funnel": "Funnel chart",
+    "scatterChart": "Scatter chart",
+    "pieChart": "Pie chart",
+    "donutChart": "Donut chart",
+    "treemap": "Treemap",
+    "map": "Map",
+    "filledMap": "Filled map",
+    "shapeMap": "Shape map",
+    "azureMap": "Azure map",
+    "gauge": "Gauge",
+    "card": "Card",
+    "multiRowCard": "Multi-row card",
+    "kpi": "KPI",
+    "slicer": "Slicer",
+    "tableEx": "Table",
+    "pivotTable": "Matrix",
+    "scriptVisual": "R script visual",
+    "pythonVisual": "Python visual",
+    "keyDriversVisual": "Key influencers",
+    "decompositionTreeVisual": "Decomposition tree",
+    "qnaVisual": "Q&A",
+    "aiNarratives": "Narrative",
+    "scorecard": "Goals (Preview)",
+    "rdlVisual": "Paginated report",
+    "cardVisual": "Card (new)",
+    "actionButton": "Button",
+    "bookmarkNavigator": "Bookmark navigator",
+    "image": "Image",
+    "textbox": "Textbox",
+    "pageNavigator": "Page navigator",
+    "shape": "Shape",
+    "Group": "Group",
+    "listSlicer": "List Slicer",
+    "advancedSlicerVisual": "Button Slicer",
+    "FlowVisual_C29F1DCC_81F5_4973_94AD_0517D44CC06A": "Power Automate for Power BI",
+}
+
+
+def generate_visual_file_path(page_file_path: str, visual_id: str) -> str:
+
+    return page_file_path.split("/page.json")[0] + f"/visuals/{visual_id}.json"
+
+
+def resolve_visual_type(visual_type: str) -> str:
+    vt_lower = visual_type.lower()
+
+    vis_map_lower = {k.lower(): v for k, v in vis_type_mapping.items()}
+    flipped_lower = {v.lower(): k for k, v in vis_type_mapping.items()}
+
+    if vt_lower in vis_map_lower:
+        resolved = vis_map_lower.get(vt_lower)
+    elif vt_lower in flipped_lower:
+        resolved = flipped_lower.get(vt_lower)
+    else:
+        raise ValueError(f"{icons.red_dot} Unknown visual type: {visual_type}")
+
+    return resolved
+
+
+page_type_mapping = {
+    (320, 240): "Tooltip",
+    (816, 1056): "Letter",
+    (960, 720): "4:3",
+    (1280, 720): "16:9",
+}
+
+page_types = ["Tooltip", "Letter", "4:3", "16:9"]
+
+
+def populate_custom_visual_display_names():
+
+    url = "https://catalogapi.azure.com/offers?api-version=2018-08-01-beta&storefront=appsource&$filter=offerType+eq+%27PowerBIVisuals%27"
+
+    def fetch_all_pages(start_url):
+        combined_json = {}
+        current_url = start_url
+
+        while current_url:
+            # Send GET request to the current page URL
+            response = requests.get(current_url)
+
+            if response.status_code == 200:
+                data = response.json()
+                # Merge the current page JSON into the combined JSON
+                for key, value in data.items():
+                    if key not in combined_json:
+                        combined_json[key] = value
+                    else:
+                        # If the key already exists and is a list, extend it
+                        if isinstance(value, list):
+                            combined_json[key].extend(value)
+                        # For other types (non-lists), update the value
+                        else:
+                            combined_json[key] = value
+
+                # Get the next page link if it exists
+                current_url = data.get("nextPageLink")
+            else:
+                print(f"Error fetching page: {response.status_code}")
+                break
+
+        return combined_json
+
+    cvJson = fetch_all_pages(url)
+
+    for i in cvJson.get("items", []):
+        vizId = i.get("powerBIVisualId")
+        displayName = i.get("displayName")
+        vis_type_mapping[vizId] = displayName
+
+
+def find_entity_property_pairs(data, result=None, keys_path=None):
+
+    if result is None:
+        result = {}
+    if keys_path is None:
+        keys_path = []
+
+    if isinstance(data, dict):
+        expression = data.get("Expression", {})
+        source_ref = (
+            expression.get("SourceRef", {}) if isinstance(expression, dict) else {}
+        )
+
+        if (
+            isinstance(source_ref, dict)
+            and "Entity" in source_ref
+            and "Property" in data
+        ):
+            entity = source_ref.get("Entity", "")
+            property_value = data.get("Property", "")
+
+            object_type = (
+                keys_path[-1].replace("HierarchyLevel", "Hierarchy")
+                if keys_path
+                else "Unknown"
+            )
+            result[property_value] = (entity, object_type)
+            if keys_path:
+                keys_path.pop()
+
+        # Recursively search the rest of the dictionary
+        for key, value in data.items():
+            keys_path.append(key)
+            find_entity_property_pairs(value, result, keys_path)
+
+    elif isinstance(data, list):
+        for item in data:
+            find_entity_property_pairs(item, result, keys_path)
+
+    return result
+
+
+def _get_agg_type_mapping() -> dict:
+    """
+    This function extracts a mapping dictionary like this:
+    {
+        "0": "Sum",
+        "1": "Average",
+        "2": "Distinct count",
+    }
+    """
+
+    schema_url = "https://developer.microsoft.com/json-schemas/fabric/item/report/definition/semanticQuery/1.2.0/schema.json"
+    response = requests.get(schema_url)
+    schema = response.json()
+    aggtypes_schema = schema.get("definitions", {}).get("QueryAggregateFunction", {})
+
+    agg_type_map = {}
+    agg_type_map = {
+        a.get("const"): a.get("description")
+        for a in aggtypes_schema.get("anyOf", [])
+        if "const" in a and "description" in a
+    }
+    agg_type_map["-1"] = "Unknown"
+
+    return agg_type_map
+
+
+def _get_expression(expr_json, agg_type_map):
+
+    expr_type = list(expr_json.keys())[0]
+    if expr_type == "Literal":
+        expr = expr_json.get("Literal", {}).get("Value")[1:-1]
+    elif expr_type == "Aggregation":
+        entity = (
+            expr_json.get("Aggregation", {})
+            .get("Expression", {})
+            .get("Column", {})
+            .get("Expression", {})
+            .get("SourceRef", {})
+            .get("Entity", "Unknown")
+        )
+        column = (
+            expr_json.get("Aggregation", {})
+            .get("Expression", {})
+            .get("Column", {})
+            .get("Property", "Unknown")
+        )
+        function_id = expr_json.get("Aggregation", {}).get("Function", "-1")
+        function = agg_type_map.get(function_id)
+        expr = f"{function}('{entity}'[{column}])"
+    elif expr_type == "Measure":
+        measure = expr_json.get("Measure", {}).get("Property", "Unknown")
+        expr = f"[{measure}]"
+    else:
+        expr = "Unknown"
+
+    return expr

sempy_labs/report/_report_list_functions.py

@@ -0,0 +1,110 @@
+import sempy.fabric as fabric
+from typing import Optional
+import pandas as pd
+from sempy_labs._helper_functions import (
+    format_dax_object_name,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+)
+from sempy_labs.report._reportwrapper import ReportWrapper
+from sempy_labs._list_functions import list_reports_using_semantic_model
+from uuid import UUID
+
+
+def list_unused_objects_in_reports(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a list of all columns in the semantic model which are not used in any related Power BI reports (including dependencies).
+    Note: As with all functions which rely on the ReportWrapper, this function requires the report to be in the 'PBIR' format.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of all columns in the semantic model which are not used in any related Power BI reports (including dependencies).
+    """
+
+    # TODO: what about relationships/RLS?
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
+
+    fabric.refresh_tom_cache(workspace=workspace)
+
+    dfR = _list_all_report_semantic_model_objects(
+        dataset=dataset_id, workspace=workspace_id
+    )
+    dfR_filt = (
+        dfR[dfR["Object Type"] == "Column"][["Table Name", "Object Name"]]
+        .drop_duplicates()
+        .reset_index(drop=True)
+    )
+    dfR_filt["Column Object"] = format_dax_object_name(
+        dfR_filt["Table Name"], dfR_filt["Object Name"]
+    )
+
+    dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id)
+    dfC["Column Object"] = format_dax_object_name(dfC["Table Name"], dfC["Column Name"])
+
+    df = dfC[~(dfC["Column Object"].isin(dfR_filt["Column Object"].values))]
+    df = df.drop("Column Object", axis=1)
+
+    return df
+
+
+def _list_all_report_semantic_model_objects(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a unique list of all semantic model objects (columns, measures, hierarchies) which are used in all reports which leverage the semantic model.
+    Note: As with all functions which rely on the ReportWrapper, this function requires the report to be in the 'PBIR' format.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
+
+    dfR = list_reports_using_semantic_model(dataset=dataset_id, workspace=workspace_id)
+    dfs = []
+
+    for _, r in dfR.iterrows():
+        report_name = r["Report Name"]
+        report_workspace = r["Report Workspace Name"]
+
+        rpt = ReportWrapper(report=report_name, workspace=report_workspace)
+
+        new_data = rpt._list_all_semantic_model_objects()
+        new_data["Report Name"] = report_name
+        new_data["Report Workspace"] = report_workspace
+        dfs.append(new_data)
+
+    df = pd.concat(dfs, ignore_index=True)
+
+    colName = "Report Name"
+    df.insert(2, colName, df.pop(colName))
+    colName = "Report Workspace"
+    df.insert(3, colName, df.pop(colName))
+
+    return df

sempy_labs/report/_report_rebind.py

@@ -0,0 +1,149 @@
+from sempy_labs._helper_functions import (
+    resolve_item_id,
+    resolve_workspace_id,
+    resolve_workspace_name_and_id,
+    resolve_item_name_and_id,
+    _base_api,
+)
+from typing import Optional, List
+from sempy._utils._log import log
+import sempy_labs._icons as icons
+from uuid import UUID
+import sempy.fabric as fabric
+
+
+@log
+def report_rebind(
+    report: str | UUID | List[str | UUID],
+    dataset: str | UUID,
+    report_workspace: Optional[str | UUID] = None,
+    dataset_workspace: Optional[str | UUID] = None,
+):
+    """
+    Rebinds a report to a semantic model.
+
+    This is a wrapper function for the following API: `Reports - Rebind Report In Group <https://learn.microsoft.com/rest/api/power-bi/reports/rebind-report-in-group>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    report : str | uuid.UUID | List[str | uuid.UUID]
+        Name(s) or ID(s) of the Power BI report(s).
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    report_workspace : str | uuid.UUID, default=None
+        The name or ID of the Fabric workspace in which the report resides.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    dataset_workspace : str | uuid.UUID, default=None
+        The name or ID of the Fabric workspace in which the semantic model resides.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    (report_workspace_name, report_workspace_id) = resolve_workspace_name_and_id(
+        report_workspace
+    )
+
+    if dataset_workspace is None:
+        dataset_workspace = report_workspace_name
+
+    (dataset_workspace_name, dataset_workspace_id) = resolve_workspace_name_and_id(
+        dataset_workspace
+    )
+    if isinstance(report, str):
+        report = [report]
+
+    for rpt in report:
+        (report_name, report_id) = resolve_item_name_and_id(
+            item=rpt, type="Report", workspace=report_workspace_id
+        )
+        (dataset_name, dataset_id) = resolve_item_name_and_id(
+            item=dataset, type="SemanticModel", workspace=dataset_workspace
+        )
+
+        payload = {"datasetId": dataset_id}
+
+        _base_api(
+            request=f"v1.0/myorg/groups/{report_workspace_id}/reports/{report_id}/Rebind",
+            method="post",
+            payload=payload,
+            client="fabric_sp",
+        )
+
+        print(
+            f"{icons.green_dot} The '{report_name}' report within the '{report_workspace_name}' workspace has been successfully rebinded to the '{dataset_name}' semantic model within the '{dataset_workspace_name}' workspace."
+        )
+
+
+@log
+def report_rebind_all(
+    dataset: str | UUID,
+    new_dataset: str | UUID,
+    dataset_workspace: Optional[str | UUID] = None,
+    new_dataset_workspace: Optional[str | UUID] = None,
+    report_workspace: Optional[str | UUID | List[str | UUID]] = None,
+):
+    """
+    Rebinds all reports across the provided report workspaces which are bound to a specific semantic model to a new semantic model.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name of the semantic model currently binded to the reports.
+    new_dataset : str | uuid.UUID
+        Name of the semantic model to rebind to the reports.
+    dataset_workspace : str | uuid.UUID, default=None
+        The name of the Fabric workspace in which the original semantic model resides.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    new_dataset_workspace : str | uuid.UUID, default=None
+        The name of the Fabric workspace in which the new semantic model resides.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    report_workspace : str | uuid.UUID | List[str | uuid.UUID], default=None
+        The name(s) or IDs of the Fabric workspace(s) in which the report(s) reside(s).
+        Defaults to None which finds all reports in all workspaces which use the semantic model and rebinds them to
+        the new semantic model.
+    """
+
+    (dataset_name, dataset_id) = resolve_item_name_and_id(
+        item=dataset, type="SemanticModel", workspace=dataset_workspace
+    )
+    new_dataset_id = resolve_item_id(
+        item=new_dataset, type="SemanticModel", workspace=new_dataset_workspace
+    )
+
+    if dataset_id == new_dataset_id:
+        raise ValueError(
+            f"{icons.red_dot} The 'dataset' and 'new_dataset' parameters are both set to the same semantic model within the same workspace. These parameters must be set to different values."
+        )
+    dataset_workspace_id = resolve_workspace_id(workspace=dataset_workspace)
+
+    if isinstance(report_workspace, str) or report_workspace is None:
+        report_workspace = [report_workspace]
+
+    for w in report_workspace:
+        dfR = fabric.list_reports(workspace=w)
+        dfR_filt = dfR[
+            (dfR["Dataset ID"] == dataset_id)
+            & (dfR["Dataset Workspace Id"] == dataset_workspace_id)
+        ]
+        if dfR_filt.empty:
+            (wksp_name, _) = resolve_workspace_name_and_id(workspace=w)
+            print(
+                f"{icons.info} No reports found for the '{dataset_name}' semantic model within the '{wksp_name}' workspace."
+            )
+        else:
+            # Rebind reports to new dataset
+            for _, r in dfR_filt.iterrows():
+                rpt_name = r["Name"]
+                report_rebind(
+                    report=rpt_name,
+                    dataset=new_dataset,
+                    report_workspace=w,
+                    dataset_workspace=new_dataset_workspace,
+                )