semantic-link-labs 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

sempy_labs/report/_report_functions.py

@@ -1,7 +1,10 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
-import json, os, time, base64, copy
+import json
+import os
+import time
+import base64
+import copy
 from anytree import Node, RenderTree
 from powerbiclient import Report
 from synapse.ml.services import Translate
@@ -16,17 +19,20 @@ 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
 
 
 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.
 
@@ -35,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
@@ -43,50 +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:
-            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.")
+        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):
@@ -124,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"]
@@ -133,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]):
@@ -182,10 +185,10 @@ def export_report(
 
     # https://learn.microsoft.com/rest/api/power-bi/reports/export-to-file-in-group
 
-    lakeAttach = lakehouse_attached()
-
-    if lakeAttach is False:
-        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.")
+    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."
+        )
 
     (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
@@ -195,10 +198,14 @@ def export_report(
         visual_name = [visual_name]
 
     if bookmark_name is not None and (page_name is not None or visual_name is not None):
-        raise ValueError(f"{icons.red_dot} If the 'bookmark_name' parameter is set, the 'page_name' and 'visual_name' parameters must not be set.")
+        raise ValueError(
+            f"{icons.red_dot} If the 'bookmark_name' parameter is set, the 'page_name' and 'visual_name' parameters must not be set."
+        )
 
     if visual_name is not None and page_name is None:
-        raise ValueError(f"{icons.red_dot} If the 'visual_name' parameter is set, the 'page_name' parameter must be set.")
+        raise ValueError(
+            f"{icons.red_dot} If the 'visual_name' parameter is set, the 'page_name' parameter must be set."
+        )
 
     validFormats = {
         "ACCESSIBLEPDF": ".pdf",
@@ -221,12 +228,14 @@ def export_report(
 
     fileExt = validFormats.get(export_format)
     if fileExt is None:
-        raise ValueError(f"{icons.red_dot} The '{export_format}' format is not a valid format for exporting Power BI reports. Please enter a valid format. Options: {validFormats}")
+        raise ValueError(
+            f"{icons.red_dot} The '{export_format}' format is not a valid format for exporting Power BI reports. Please enter a valid format. Options: {validFormats}"
+        )
 
     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)
@@ -238,7 +247,9 @@ def export_report(
     ]
 
     if len(dfI_filt) == 0:
-        raise ValueError(f"{icons.red_dot} The '{report}' report does not exist in the '{workspace}' workspace.")
+        raise ValueError(
+            f"{icons.red_dot} The '{report}' report does not exist in the '{workspace}' workspace."
+        )
 
     reportType = dfI_filt["Type"].iloc[0]
 
@@ -259,15 +270,21 @@ def export_report(
     ]
 
     if reportType == "Report" and export_format in paginatedOnly:
-        raise ValueError(f"{icons.red_dot} The '{export_format}' format is only supported for paginated reports.")
+        raise ValueError(
+            f"{icons.red_dot} The '{export_format}' format is only supported for paginated reports."
+        )
 
     if reportType == "PaginatedReport" and export_format in pbiOnly:
-        raise ValueError(f"{icons.red_dot} The '{export_format}' format is only supported for Power BI reports.")
+        raise ValueError(
+            f"{icons.red_dot} The '{export_format}' format is only supported for Power BI reports."
+        )
 
     if reportType == "PaginatedReport" and (
         bookmark_name is not None or page_name is not None or visual_name is not None
     ):
-        raise ValueError(f"{icons.red_dot} Export for paginated reports does not support bookmarks/pages/visuals. Those parameters must not be set for paginated reports.")
+        raise ValueError(
+            f"{icons.red_dot} Export for paginated reports does not support bookmarks/pages/visuals. Those parameters must not be set for paginated reports."
+        )
 
     reportId = dfI_filt["Id"].iloc[0]
     client = fabric.PowerBIRestClient()
@@ -304,14 +321,18 @@ def export_report(
             for page in page_name:
                 dfPage_filt = dfPage[dfPage["Page ID"] == page]
                 if len(dfPage_filt) == 0:
-                    raise ValueError(f"{icons.red_dot} The '{page}' page does not exist in the '{report}' report within the '{workspace}' workspace.")
+                    raise ValueError(
+                        f"{icons.red_dot} The '{page}' page does not exist in the '{report}' report within the '{workspace}' workspace."
+                    )
 
                 page_dict = {"pageName": page}
                 request_body["powerBIReportConfiguration"]["pages"].append(page_dict)
 
     elif page_name is not None and visual_name is not None:
         if len(page_name) != len(visual_name):
-            raise ValueError(f"{icons.red_dot} Each 'visual_name' must map to a single 'page_name'.")
+            raise ValueError(
+                f"{icons.red_dot} Each 'visual_name' must map to a single 'page_name'."
+            )
 
         if reportType == "Report":
             request_body = {"format": export_format, "powerBIReportConfiguration": {}}
@@ -324,7 +345,9 @@ def export_report(
                     (dfVisual["Page ID"] == page) & (dfVisual["Visual ID"] == visual)
                 ]
                 if len(dfVisual_filt) == 0:
-                    raise ValueError(f"{icons.red_dot} The '{visual}' visual does not exist on the '{page}' in the '{report}' report within the '{workspace}' workspace.")
+                    raise ValueError(
+                        f"{icons.red_dot} The '{visual}' visual does not exist on the '{page}' in the '{report}' report within the '{workspace}' workspace."
+                    )
 
                 page_dict = {"pageName": page, "visualName": visual}
                 request_body["powerBIReportConfiguration"]["pages"].append(page_dict)
@@ -359,7 +382,9 @@ def export_report(
             )
             response_body = json.loads(response.content)
         if response_body["status"] == "Failed":
-            raise ValueError(f"{icons.red_dot} The export for the '{report}' report within the '{workspace}' workspace in the '{export_format}' format has failed.")
+            raise ValueError(
+                f"{icons.red_dot} The export for the '{report}' report within the '{workspace}' workspace in the '{export_format}' format has failed."
+            )
         else:
             response = client.get(
                 f"/v1.0/myorg/groups/{workspace_id}/reports/{reportId}/exports/{exportId}/file"
@@ -411,7 +436,9 @@ def clone_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 within the '{workspace}' workspace.")
+        raise ValueError(
+            f"{icons.red_dot} The '{report}' report does not exist within the '{workspace}' workspace."
+        )
 
     reportId = resolve_report_id(report, workspace)
 
@@ -423,7 +450,9 @@ def clone_report(
         dfW_filt = dfW[dfW["Name"] == target_workspace]
 
         if len(dfW_filt) == 0:
-            raise ValueError(f"{icons.red_dot} The '{workspace}' is not a valid workspace.")
+            raise ValueError(
+                f"{icons.red_dot} The '{workspace}' is not a valid workspace."
+            )
 
         target_workspace_id = dfW_filt["Id"].iloc[0]
 
@@ -439,7 +468,9 @@ def clone_report(
         dfD_filt = dfD[dfD["Dataset Name"] == target_dataset]
 
         if len(dfD_filt) == 0:
-            raise ValueError(f"{icons.red_dot} The '{target_dataset}' target dataset does not exist in the '{target_workspace}' workspace.")
+            raise ValueError(
+                f"{icons.red_dot} The '{target_dataset}' target dataset does not exist in the '{target_workspace}' workspace."
+            )
 
         target_dataset_id = dfD_filt["Dataset Id"].iloc[0]
 
@@ -462,12 +493,12 @@ def clone_report(
         f"/v1.0/myorg/groups/{workspace_id}/reports/{reportId}/Clone", json=request_body
     )
 
-    if response.status_code == 200:
-        print(
-            f"{icons.green_dot} The '{report}' report has been successfully cloned as the '{cloned_report}' report within the '{target_workspace}' workspace using the '{target_dataset}' semantic model."
-        )
-    else:
-        raise ValueError(f"{icons.red_dot} POST request failed with status code: {response.status_code}")
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+    print(
+        f"{icons.green_dot} The '{report}' report has been successfully cloned as the '{cloned_report}' report within the"
+        f" '{target_workspace}' workspace using the '{target_dataset}' semantic model."
+    )
 
 
 def launch_report(report: str, workspace: Optional[str] = None):
@@ -544,7 +575,7 @@ def list_report_pages(report: str, workspace: Optional[str] = None):
             pageH = pageConfigJson["visibility"]
             if pageH == 1:
                 pageHidden = True
-        except:
+        except Exception:
             pass
 
         new_data = {
@@ -605,7 +636,7 @@ def list_report_visuals(report: str, workspace: Optional[str] = None):
                     "properties"
                 ]["text"]["expr"]["Literal"]["Value"]
                 title = title[1:-1]
-            except:
+            except Exception:
                 title = ""
 
             new_data = {
@@ -673,7 +704,7 @@ def list_report_bookmarks(report: str, workspace: Optional[str] = None):
                         ][vc]["singleVisual"]["display"]["mode"]
                         if hidden == "hidden":
                             vHidden = True
-                    except:
+                    except Exception:
                         pass
 
             new_data = {
@@ -701,7 +732,7 @@ def list_report_bookmarks(report: str, workspace: Optional[str] = None):
 
         return df
 
-    except:
+    except Exception:
         print(
             f"The '{report}' report within the '{workspace}' workspace has no bookmarks."
         )

sempy_labs/report/_report_rebind.py

@@ -1,9 +1,10 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs._helper_functions import resolve_dataset_id, resolve_report_id
 from typing import Optional, List
 from sempy._utils._log import log
 import sempy_labs._icons as icons
+from sempy.fabric.exceptions import FabricHTTPException
+
 
 @log
 def report_rebind(
@@ -47,7 +48,7 @@ def report_rebind(
 
     if isinstance(report, str):
         report = [report]
-    
+
     for rpt in report:
         reportId = resolve_report_id(report=rpt, workspace=report_workspace)
         datasetId = resolve_dataset_id(dataset=dataset, workspace=dataset_workspace)
@@ -60,12 +61,12 @@ def report_rebind(
             json=request_body,
         )
 
-        if response.status_code == 200:
-            print(
-                f"{icons.green_dot} The '{rpt}' report has been successfully rebinded to the '{dataset}' semantic model."
-            )
-        else:
-            raise ValueError(f"{icons.red_dot} The '{rpt}' report within the '{report_workspace}' workspace failed to rebind to the '{dataset}' semantic model within the '{dataset_workspace}' workspace.")
+        if response.status_code != 200:
+            raise FabricHTTPException(response)
+        print(
+            f"{icons.green_dot} The '{rpt}' report has been successfully rebinded to the '{dataset}' semantic model."
+        )
+
 
 @log
 def report_rebind_all(
@@ -76,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
@@ -96,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,
+        )

sempy_labs/tom/__init__.py

@@ -1,6 +1,3 @@
 from sempy_labs.tom._model import TOMWrapper, connect_semantic_model
 
-__all__ = [
-    "TOMWrapper",
-    "connect_semantic_model"
-]
+__all__ = ["TOMWrapper", "connect_semantic_model"]