semantic-link-labs 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

sempy_labs/report/_generate_report.py

@@ -1,11 +1,18 @@
 import sempy.fabric as fabric
 import pandas as pd
 import json
-import base64
+import os
 import time
 from typing import Optional
-from sempy_labs._helper_functions import resolve_workspace_name_and_id
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+    _conv_b64,
+    resolve_report_id,
+    lro,
+)
 import sempy_labs._icons as icons
+from sempy._utils._log import log
+from sempy.fabric.exceptions import FabricHTTPException
 
 
 def create_report_from_reportjson(
@@ -36,10 +43,9 @@ def create_report_from_reportjson(
 
     (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
-    objectType = "Report"
+    dfI = fabric.list_items(workspace=workspace)
 
-    dfI_m = fabric.list_items(workspace=workspace, type="SemanticModel")
-    dfI_model = dfI_m[(dfI_m["Display Name"] == dataset)]
+    dfI_model = dfI[(dfI["Display Name"] == dataset) & (dfI["Type"] == "SemanticModel")]
 
     if len(dfI_model) == 0:
         raise ValueError(
@@ -48,8 +54,7 @@ def create_report_from_reportjson(
 
     datasetId = dfI_model["Id"].iloc[0]
 
-    dfI_r = fabric.list_items(workspace=workspace, type="Report")
-    dfI_rpt = dfI_r[(dfI_r["Display Name"] == report)]
+    dfI_rpt = dfI[(dfI["Display Name"] == report) & (dfI["Type"] == "Report")]
 
     if len(dfI_rpt) > 0:
         print(
@@ -73,83 +78,50 @@ def create_report_from_reportjson(
         },
     }
 
-    def conv_b64(file):
-
-        loadJson = json.dumps(file)
-        f = base64.b64encode(loadJson.encode("utf-8")).decode("utf-8")
-
-        return f
-
-    definitionPBIR = conv_b64(defPBIR)
-    payloadReportJson = conv_b64(report_json)
-
-    if theme_json is None:
-        request_body = {
-            "displayName": report,
-            "type": objectType,
-            "definition": {
-                "parts": [
-                    {
-                        "path": "report.json",
-                        "payload": payloadReportJson,
-                        "payloadType": "InlineBase64",
-                    },
-                    {
-                        "path": "definition.pbir",
-                        "payload": definitionPBIR,
-                        "payloadType": "InlineBase64",
-                    },
-                ]
-            },
-        }
-    else:
-        payloadThemeJson = conv_b64(theme_json)
-        themeID = theme_json["payload"]["blob"]["displayName"]
-        themePath = "StaticResources/SharedResources/BaseThemes/" + themeID + ".json"
-        request_body = {
-            "displayName": report,
-            "type": objectType,
-            "definition": {
-                "parts": [
-                    {
-                        "path": "report.json",
-                        "payload": payloadReportJson,
-                        "payloadType": "InlineBase64",
-                    },
-                    {
-                        "path": themePath,
-                        "payload": payloadThemeJson,
-                        "payloadType": "InlineBase64",
-                    },
-                    {
-                        "path": "definition.pbir",
-                        "payload": definitionPBIR,
-                        "payloadType": "InlineBase64",
-                    },
-                ]
-            },
+    definitionPBIR = _conv_b64(defPBIR)
+    payloadReportJson = _conv_b64(report_json)
+
+    request_body = {
+        "displayName": report,
+        "definition": {
+            "parts": [
+                {
+                    "path": "report.json",
+                    "payload": payloadReportJson,
+                    "payloadType": "InlineBase64",
+                },
+                {
+                    "path": "definition.pbir",
+                    "payload": definitionPBIR,
+                    "payloadType": "InlineBase64",
+                },
+            ]
+        },
+    }
+
+    if theme_json is not None:
+        theme_payload = _conv_b64(theme_json)
+        theme_id = theme_json["payload"]["blob"]["displayName"]
+        theme_path = f"StaticResources/SharedResources/BaseThemes/{theme_id}.json"
+
+        part = {
+            "path": theme_path,
+            "payload": theme_payload,
+            "payloadType": "InlineBase64",
         }
+        request_body["definition"]["parts"].append(part)
+
+    response = client.post(f"/v1/workspaces/{workspace_id}/reports", json=request_body)
 
-    response = client.post(f"/v1/workspaces/{workspace_id}/items", json=request_body)
+    lro(client, response, status_codes=[201, 202])
 
-    if response.status_code == 201:
-        print(f"{icons.green_dot} Report creation succeeded")
-        print(response.json())
-    elif response.status_code == 202:
-        operationId = response.headers["x-ms-operation-id"]
-        response = client.get(f"/v1/operations/{operationId}")
-        response_body = json.loads(response.content)
-        while response_body["status"] != "Succeeded":
-            time.sleep(3)
-            response = client.get(f"/v1/operations/{operationId}")
-            response_body = json.loads(response.content)
-        response = client.get(f"/v1/operations/{operationId}/result")
-        print(f"{icons.green_dot} Report creation succeeded")
-        print(response.json())
+    print(
+        f"{icons.green_dot} Succesfully created the '{report}' report within the '{workspace}' workspace."
+    )
 
 
 def update_report_from_reportjson(
-    report: str, report_json: str, workspace: Optional[str] = None
+    report: str, report_json: dict, workspace: Optional[str] = None
 ):
     """
     Updates a report based on a report.json file.
@@ -158,7 +130,7 @@ def update_report_from_reportjson(
     ----------
     report : str
         Name of the report.
-    report_json : str
+    report_json : dict
         The report.json file to be used to update the report.
     workspace : str, default=None
         The Fabric workspace name in which the report resides.
@@ -167,55 +139,15 @@ def update_report_from_reportjson(
     """
 
     (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    report_id = resolve_report_id(report=report, workspace=workspace)
 
-    dfR = fabric.list_reports(workspace=workspace)
-    dfR_filt = dfR[(dfR["Name"] == report) & (dfR["Report Type"] == "PowerBIReport")]
-
-    if len(dfR_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{report}' report does not exist in the '{workspace}' workspace."
-        )
-
-    reportId = dfR_filt["Id"].iloc[0]
-    client = fabric.FabricRestClient()
-
-    response = client.post(
-        f"/v1/workspaces/{workspace_id}/items/{reportId}/getDefinition"
-    )
-    df_items = pd.json_normalize(response.json()["definition"]["parts"])
+    # Get the existing PBIR file
+    df_items = get_report_definition(report=report, workspace=workspace)
     df_items_filt = df_items[df_items["path"] == "definition.pbir"]
     rptDefFile = df_items_filt["payload"].iloc[0]
-    # datasetId = dfR_filt['Dataset Id'].iloc[0]
-    # datasetWorkspaceId = dfR_filt['Dataset Workspace Id'].iloc[0]
-
-    # defPBIR = {
-    # "version": "1.0",
-    # "datasetReference": {
-    #    "byPath": None,
-    #    "byConnection": {
-    #        "connectionString": None,
-    #        "pbiServiceModelId": None,
-    #        "pbiModelVirtualServerName": "sobe_wowvirtualserver",
-    #        "pbiModelDatabaseName": datasetId,
-    #        "name": "EntityDataSource",
-    #        "connectionType": "pbiServiceXmlaStyleLive"
-    #    }
-    # }
-    # }
-
-    def conv_b64(file):
-
-        loadJson = json.dumps(file)
-        f = base64.b64encode(loadJson.encode("utf-8")).decode("utf-8")
-
-        return f
-
-    # definitionPBIR = conv_b64(defPBIR)
-    payloadReportJson = conv_b64(report_json)
+    payloadReportJson = _conv_b64(report_json)
 
     request_body = {
-        "displayName": report,
-        "type": "Report",
         "definition": {
             "parts": [
                 {
@@ -229,25 +161,209 @@ def update_report_from_reportjson(
                     "payloadType": "InlineBase64",
                 },
             ]
-        },
+        }
     }
 
+    client = fabric.FabricRestClient()
     response = client.post(
-        f"/v1/workspaces/{workspace_id}/reports/{reportId}/updateDefinition",
+        f"/v1/workspaces/{workspace_id}/reports/{report_id}/updateDefinition",
         json=request_body,
     )
 
-    if response.status_code == 201:
-        print(f"{icons.green_dot} The '{report}' report has been successfully updated.")
-        # print(response.json())
-    elif response.status_code == 202:
-        operationId = response.headers["x-ms-operation-id"]
-        response = client.get(f"/v1/operations/{operationId}")
-        response_body = json.loads(response.content)
-        while response_body["status"] != "Succeeded":
-            time.sleep(3)
-            response = client.get(f"/v1/operations/{operationId}")
-            response_body = json.loads(response.content)
-        response = client.get(f"/v1/operations/{operationId}/result")
-        print(f"{icons.green_dot} The '{report}' report has been successfully updated.")
-        # print(response.json())
+    lro(client, response, return_status_code=True)
+
+    print(
+        f"{icons.green_dot} The '{report}' report within the '{workspace}' workspace has been successfully updated."
+    )
+
+
+def get_report_definition(report: str, workspace: Optional[str] = None) -> pd.DataFrame:
+    """
+    Gets the collection of definition files of a report.
+
+    Parameters
+    ----------
+    report : str
+        Name of the report.
+    workspace : str, default=None
+        The Fabric workspace name 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.
+
+    Returns
+    -------
+    pandas.DataFrame
+        The collection of report definition files within a pandas dataframe.
+    """
+
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    report_id = resolve_report_id(report=report, workspace=workspace)
+    client = fabric.FabricRestClient()
+    response = client.post(
+        f"/v1/workspaces/{workspace_id}/reports/{report_id}/getDefinition",
+    )
+
+    result = lro(client, response).json()
+    rdef = pd.json_normalize(result["definition"]["parts"])
+
+    return rdef
+
+
+@log
+def create_model_bpa_report(
+    report: Optional[str] = icons.model_bpa_name,
+    dataset: Optional[str] = icons.model_bpa_name,
+    dataset_workspace: Optional[str] = None,
+):
+    """
+    Dynamically generates a Best Practice Analyzer report for analyzing semantic models.
+
+    Parameters
+    ----------
+    report : str, default='ModelBPA'
+        Name of the report.
+        Defaults to 'ModelBPA'.
+    dataset : str, default='ModelBPA'
+        Name of the semantic model which feeds this report.
+        Defaults to 'ModelBPA'
+    dataset_workspace : str, default=None
+        The Fabric workspace name 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.
+
+    """
+
+    # from sempy_labs._helper_functions import resolve_dataset_id
+
+    dfI = fabric.list_items(workspace=dataset_workspace, type="SemanticModel")
+    dfI_filt = dfI[dfI["Display Name"] == dataset]
+
+    if len(dfI_filt) == 0:
+        raise ValueError(
+            f"The '{dataset}' semantic model does not exist within the '{dataset_workspace}' workspace."
+        )
+
+    dfR = fabric.list_reports(workspace=dataset_workspace)
+    dfR_filt = dfR[dfR["Name"] == report]
+    # dataset_id = resolve_dataset_id(dataset=dataset, workspace=dataset_workspace)
+
+    current_dir = os.path.dirname(__file__)
+    # directory_path = os.path.join(current_dir, "_bpareporttemplate")
+    # len_dir_path = len(directory_path) + 1
+
+    # request_body = {"displayName": report, "definition": {"parts": []}}
+
+    # def get_all_file_paths(directory):
+    #    file_paths = []
+
+    #    for root, directories, files in os.walk(directory):
+    #        for filename in files:
+    #            full_path = os.path.join(root, filename)
+    #            file_paths.append(full_path)
+
+    #    return file_paths
+
+    # all_files = get_all_file_paths(directory_path)
+
+    # for file_path in all_files:
+    #    fp = file_path[len_dir_path:]
+    #    with open(file_path, "r") as file:
+    #        json_file = json.load(file)
+    #        if fp == 'definition.pbir':
+    #            conn_string = f"Data Source=powerbi://api.powerbi.com/v1.0/myorg/{dataset_workspace};Initial Catalog={dataset};Integrated Security=ClaimsToken"
+    #            json_file['datasetReference']['byConnection']['connectionString'] = conn_string
+    #            json_file['datasetReference']['byConnection']['pbiModelDatabaseName'] = dataset_id
+    #        part = {
+    #            "path": fp,
+    #            "payload": _conv_b64(json_file),
+    #            "payloadType": "InlineBase64",
+    #        }
+
+    #    request_body["definition"]["parts"].append(part)
+
+    # _create_report(
+    #    report=report,
+    #    request_body=request_body,
+    #    dataset=dataset,
+    #    report_workspace=dataset_workspace,
+    #    dataset_workspace=dataset_workspace,
+    # )
+
+    json_file_path = os.path.join(current_dir, "_BPAReportTemplate.json")
+    with open(json_file_path, "r") as file:
+        report_json = json.load(file)
+
+    if len(dfR_filt) > 0:
+        update_report_from_reportjson(
+            report=report, report_json=report_json, workspace=dataset_workspace
+        )
+    else:
+        create_report_from_reportjson(
+            report=report,
+            dataset=dataset,
+            report_json=report_json,
+            workspace=dataset_workspace,
+        )
+
+
+def _create_report(
+    report: str,
+    request_body: dict,
+    dataset: str,
+    dataset_workspace: Optional[str] = None,
+    report_workspace: Optional[str] = None,
+    update_if_exists: Optional[bool] = False,
+):
+
+    from sempy_labs.report import report_rebind
+
+    report_workspace = fabric.resolve_workspace_name(report_workspace)
+    report_workspace_id = fabric.resolve_workspace_id(report_workspace)
+    client = fabric.FabricRestClient()
+
+    dfR = fabric.list_reports(workspace=report_workspace)
+    dfR_filt = dfR[dfR["Name"] == report]
+
+    updated_report = False
+
+    # Create report if it does not exist
+    if len(dfR_filt) == 0:
+        response = client.post(
+            f"/v1/workspaces/{report_workspace_id}/reports",
+            json=request_body,
+            lro_wait=True,
+        )
+        if response.status_code not in [200, 201]:
+            raise FabricHTTPException(response)
+        print(
+            f"{icons.green_dot} The '{report}' report has been created within the '{report_workspace}'"
+        )
+        updated_report = True
+    # Update the report if it exists
+    elif len(dfR_filt) > 0 and update_if_exists:
+        report_id = dfR_filt["Id"].iloc[0]
+        response = client.post(
+            f"/v1/workspaces/{report_workspace_id}/reports/{report_id}/updateDefinition",
+            json=request_body,
+            lro_wait=True,
+        )
+        if response.status_code not in [200, 201]:
+            raise FabricHTTPException(response)
+        print(
+            f"{icons.green_dot} The '{report}' report has been updated within the '{report_workspace}'"
+        )
+        updated_report = True
+    else:
+        raise ValueError(
+            f"{icons.red_dot} The '{report}' report within the '{report_workspace}' workspace already exists and it was selected not to update it if the report already exists."
+        )
+
+    # Rebind the report to the semantic model to make sure it is pointed at the correct semantic model
+    if updated_report:
+        report_rebind(
+            report=report,
+            dataset=dataset,
+            report_workspace=report_workspace,
+            dataset_workspace=dataset_workspace,
+        )

sempy_labs/report/_report_functions.py

@@ -19,8 +19,10 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     language_validate,
     resolve_workspace_name_and_id,
+    lro,
+    _decode_b64,
 )
-from typing import Any, List, Optional, Union
+from typing import List, Optional, Union
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
@@ -30,7 +32,7 @@ def get_report_json(
     report: str,
     workspace: Optional[str] = None,
     save_to_file_name: Optional[str] = None,
-) -> Any:
+) -> dict:
     """
     Gets the report.json file content of a Power BI report.
 
@@ -39,7 +41,7 @@ def get_report_json(
     report : str
         Name of the Power BI report.
     workspace : str, default=None
-        The Fabric workspace name.
+        The Fabric workspace name in which the report exists.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     save_to_file_name : str, default=None
@@ -47,54 +49,47 @@ def get_report_json(
 
     Returns
     -------
-    Any
+    dict
         The report.json file for a given Power BI report.
     """
 
     (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    report_id = resolve_report_id(report=report, workspace=workspace)
+    fmt = "PBIR-Legacy"
 
     client = fabric.FabricRestClient()
-
-    dfI = fabric.list_items(workspace=workspace, type="Report")
-    dfI_filt = dfI[(dfI["Display Name"] == report)]
-
-    if len(dfI_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{report}' report does not exist in the '{workspace}' workspace."
-        )
-
-    itemId = dfI_filt["Id"].iloc[0]
     response = client.post(
-        f"/v1/workspaces/{workspace_id}/items/{itemId}/getDefinition"
+        f"/v1/workspaces/{workspace_id}/reports/{report_id}/getDefinition?format={fmt}"
     )
-    df_items = pd.json_normalize(response.json()["definition"]["parts"])
+
+    result = lro(client, response).json()
+    df_items = pd.json_normalize(result["definition"]["parts"])
     df_items_filt = df_items[df_items["path"] == "report.json"]
     payload = df_items_filt["payload"].iloc[0]
-
-    reportFile = base64.b64decode(payload).decode("utf-8")
-    reportJson = json.loads(reportFile)
+    report_file = _decode_b64(payload)
+    report_json = json.loads(report_file)
 
     if save_to_file_name is not None:
-        lakeAttach = lakehouse_attached()
-        if lakeAttach is False:
+        if not lakehouse_attached():
             raise ValueError(
                 f"{icons.red_dot} In order to save the report.json file, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
             )
 
         lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, workspace)
+        lake_workspace = fabric.resolve_workspace_name()
+        lakehouse = resolve_lakehouse_name(lakehouse_id, lake_workspace)
         folderPath = "/lakehouse/default/Files"
         fileExt = ".json"
         if not save_to_file_name.endswith(fileExt):
-            save_to_file_name = save_to_file_name + fileExt
+            save_to_file_name = f"{save_to_file_name}{fileExt}"
         filePath = os.path.join(folderPath, save_to_file_name)
         with open(filePath, "w") as json_file:
-            json.dump(reportJson, json_file, indent=4)
+            json.dump(report_json, json_file, indent=4)
         print(
             f"{icons.green_dot} The report.json file for the '{report}' report has been saved to the '{lakehouse}' in this location: '{filePath}'.\n\n"
         )
 
-    return reportJson
+    return report_json
 
 
 def report_dependency_tree(workspace: Optional[str] = None):
@@ -132,7 +127,7 @@ def report_dependency_tree(workspace: Optional[str] = None):
     node_dict = {}
     rootNode = Node(workspace)
     node_dict[workspace] = rootNode
-    rootNode.custom_property = workspace_icon + " "
+    rootNode.custom_property = f"{workspace_icon} "
 
     for i, r in dfR.iterrows():
         datasetName = r["Dataset Name"]
@@ -141,10 +136,10 @@ def report_dependency_tree(workspace: Optional[str] = None):
         if parentNode is None:
             parentNode = Node(datasetName, parent=rootNode)
             node_dict[datasetName] = parentNode
-        parentNode.custom_property = dataset_icon + " "
+        parentNode.custom_property = f"{dataset_icon} "
 
         child_node = Node(reportName, parent=parentNode)
-        child_node.custom_property = report_icon + " "
+        child_node.custom_property = f"{report_icon} "
 
     # Print the tree structure
     for pre, _, node in RenderTree(node_dict[workspace]):
@@ -190,9 +185,7 @@ def export_report(
 
     # https://learn.microsoft.com/rest/api/power-bi/reports/export-to-file-in-group
 
-    lakeAttach = lakehouse_attached()
-
-    if lakeAttach is False:
+    if not lakehouse_attached():
         raise ValueError(
             f"{icons.red_dot} In order to run the 'export_report' function, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
         )
@@ -240,9 +233,9 @@ def export_report(
         )
 
     if file_name is None:
-        file_name = report + fileExt
+        file_name = f"{report}{fileExt}"
     else:
-        file_name = file_name + fileExt
+        file_name = f"{file_name}{fileExt}"
 
     folderPath = "/lakehouse/default/Files"
     filePath = os.path.join(folderPath, file_name)

sempy_labs/report/_report_rebind.py

@@ -77,12 +77,10 @@ def report_rebind_all(
     report_workspace: Optional[str | List[str]] = None,
 ):
     """
-    Rebinds all reports in a workspace which are bound to a specific semantic model to a new semantic model.
+    Rebinds all reports across all workspaces which are bound to a specific semantic model to a new semantic model.
 
     Parameters
     ----------
-    report : str
-        Name of the Power BI report.
     dataset : str
         Name of the semantic model currently binded to the reports.
     new_dataset : str
@@ -97,35 +95,42 @@ def report_rebind_all(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     report_workspace : str | List[str], default=None
         The name(s) of the Fabric workspace(s) in which the report(s) reside(s).
-        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
-    -------
-
+        Defaults to None which finds all reports in all workspaces which use the semantic model and rebinds them to
+        the new semantic model.
     """
 
-    dataset_workspace = fabric.resolve_workspace_name()
+    from sempy_labs._list_functions import list_reports_using_semantic_model
+
+    dataset_workspace = fabric.resolve_workspace_name(dataset_workspace)
 
     if new_dataset_workpace is None:
         new_dataset_workpace = dataset_workspace
 
-    if report_workspace is None:
-        report_workspace = dataset_workspace
-
     if isinstance(report_workspace, str):
         report_workspace = [report_workspace]
 
-    datasetId = resolve_dataset_id(dataset, dataset_workspace)
-
-    for rw in report_workspace:
-        dfRep = fabric.list_reports(workspace=rw)
-        dfRep_filt = dfRep[dfRep["Dataset Id"] == datasetId]
-        for i, r in dfRep_filt.iterrows():
-            rptName = r["Name"]
-            report_rebind(
-                report=rptName,
-                dataset=new_dataset,
-                report_workspace=rw,
-                dataset_workspace=new_dataset_workpace,
-            )
+    dfR = list_reports_using_semantic_model(
+        dataset=dataset, workspace=dataset_workspace
+    )
+
+    if len(dfR) == 0:
+        print(
+            f"{icons.info} The '{dataset}' semantic model within the '{dataset_workspace}' workspace has no dependent reports."
+        )
+        return
+
+    if report_workspace is None:
+        dfR_filt = dfR.copy()
+    else:
+        dfR_filt = dfR[dfR["Report Workspace Name"].isin(report_workspace)]
+
+    for i, r in dfR_filt.iterrows():
+        rpt_name = r["Report Name"]
+        rpt_wksp = r["Report Workspace Name"]
+
+        report_rebind(
+            report=rpt_name,
+            dataset=new_dataset,
+            report_workspace=rpt_wksp,
+            dataset_workspace=new_dataset_workpace,
+        )