semantic-link-labs 0.8.9__py3-none-any.whl → 0.8.11__py3-none-any.whl

sempy_labs/migration/_create_pqt_file.py

@@ -1,5 +1,4 @@
 import sempy
-import sempy.fabric as fabric
 import json
 import os
 import shutil
@@ -7,12 +6,17 @@ from sempy_labs.lakehouse._lakehouse import lakehouse_attached
 from sempy._utils._log import log
 from typing import Optional
 import sempy_labs._icons as icons
+from uuid import UUID
+from sempy_labs._helper_functions import (
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
+)
 
 
 @log
 def create_pqt_file(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     file_name: str = "PowerQueryTemplate",
 ):
     """
@@ -24,10 +28,10 @@ def create_pqt_file(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    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.
     file_name : str, default='PowerQueryTemplate'
@@ -43,19 +47,20 @@ def create_pqt_file(
             f"{icons.red_dot} In order to run the 'create_pqt_file' function, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
         )
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     folderPath = "/lakehouse/default/Files"
     subFolderPath = os.path.join(folderPath, "pqtnewfolder")
 
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=True
+        dataset=dataset_id, workspace=workspace_id, readonly=True
     ) as tom:
         if not any(
             p.SourceType == TOM.PartitionSourceType.M for p in tom.all_partitions()
         ) and not any(t.RefreshPolicy for t in tom.model.Tables):
             print(
-                f"{icons.info} The '{dataset}' semantic model within the '{workspace}' workspace has no Power Query logic."
+                f"{icons.info} The '{dataset_name}' semantic model within the '{workspace_name}' workspace has no Power Query logic."
             )
             return
 
@@ -220,7 +225,7 @@ def create_pqt_file(
             shutil.rmtree(subFolderPath, ignore_errors=True)
 
             print(
-                f"{icons.green_dot} '{file_name}.pqt' has been created based on the '{dataset}' semantic model in the '{workspace}' workspace within the Files section of your lakehouse."
+                f"{icons.green_dot} '{file_name}.pqt' has been created based on the '{dataset_name}' semantic model in the '{workspace_name}' workspace within the Files section of your lakehouse."
             )
 
         a = 0

sempy_labs/migration/_refresh_calc_tables.py

@@ -7,25 +7,31 @@ from sempy_labs.tom import connect_semantic_model
 from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
+from uuid import UUID
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+)
 
 
 @log
-def refresh_calc_tables(dataset: str, workspace: Optional[str] = None):
+def refresh_calc_tables(dataset: str | UUID, workspace: Optional[str | UUID] = None):
     """
     Recreates the delta tables in the lakehouse based on the DAX expressions stored as model annotations in the Direct Lake semantic model.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    dataset : str | UUID
+        Name or ID of the semantic model.
+    workspace : str | 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.
     """
 
     spark = SparkSession.builder.getOrCreate()
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
     icons.sll_tags.append("DirectLakeMigration")
 
     @retry(
@@ -34,7 +40,7 @@ def refresh_calc_tables(dataset: str, workspace: Optional[str] = None):
     )
     def dyn_connect():
         with connect_semantic_model(
-            dataset=dataset, readonly=True, workspace=workspace
+            dataset=dataset_id, readonly=True, workspace=workspace_id
         ) as tom:
 
             tom.model
@@ -42,7 +48,7 @@ def refresh_calc_tables(dataset: str, workspace: Optional[str] = None):
     dyn_connect()
 
     with connect_semantic_model(
-        dataset=dataset, readonly=True, workspace=workspace
+        dataset=dataset_id, readonly=True, workspace=workspace_id
     ) as tom:
         for a in tom.model.Annotations:
             if any(a.Name == t.Name for t in tom.model.Tables):
@@ -56,9 +62,9 @@ def refresh_calc_tables(dataset: str, workspace: Optional[str] = None):
 
                 try:
                     df = fabric.evaluate_dax(
-                        dataset=dataset,
+                        dataset=dataset_id,
                         dax_string=daxquery,
-                        workspace=workspace,
+                        workspace=workspace_id,
                     )
 
                     # Update column names for non-field parameters

sempy_labs/report/_download_report.py

@@ -7,13 +7,14 @@ from sempy_labs._helper_functions import (
 )
 from sempy_labs.lakehouse._lakehouse import lakehouse_attached
 from sempy.fabric.exceptions import FabricHTTPException
+from uuid import UUID
 
 
 def download_report(
     report: str,
     file_name: Optional[str] = None,
     download_type: str = "LiveConnect",
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Downloads the specified report from the specified workspace to a Power BI .pbix file.
@@ -29,8 +30,8 @@ def download_report(
         Defaults to None which resolves to the name of the report.
     download_type : str, default="LiveConnect"
         The type of download. Valid values are "LiveConnect" and "IncludeModel".
-    workspace : str, default=None
-        The Fabric workspace name.
+    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.
     """
@@ -40,10 +41,11 @@ def download_report(
             f"{icons.red_dot} A lakehouse must be attached to the notebook."
         )
 
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     lakehouse_id = fabric.get_lakehouse_id()
-    workspace_name = fabric.resolve_workspace_name()
+    lakehouse_workspace = fabric.resolve_workspace_name()
     lakehouse_name = resolve_lakehouse_name(
-        lakehouse_id=lakehouse_id, workspace=workspace_name
+        lakehouse_id=lakehouse_id, workspace=lakehouse_workspace
     )
 
     download_types = ["LiveConnect", "IncludeModel"]
@@ -53,9 +55,8 @@ def download_report(
         )
 
     file_name = file_name or report
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
     report_id = fabric.resolve_item_id(
-        item_name=report, type="Report", workspace=workspace
+        item_name=report, type="Report", workspace=workspace_id
     )
 
     client = fabric.PowerBIRestClient()
@@ -71,5 +72,5 @@ def download_report(
         file.write(response.content)
 
     print(
-        f"{icons.green_dot} The '{report}' report within the '{workspace}' workspace has been exported as the '{file_name}' file in the '{lakehouse_name}' lakehouse within the '{workspace_name} workspace."
+        f"{icons.green_dot} The '{report}' report within the '{workspace_name}' workspace has been exported as the '{file_name}' file in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
     )

sempy_labs/report/_generate_report.py

@@ -7,18 +7,20 @@ from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     _conv_b64,
     resolve_report_id,
+    resolve_dataset_name_and_id,
     lro,
 )
 import sempy_labs._icons as icons
 from sempy._utils._log import log
+from uuid import UUID
 
 
 def create_report_from_reportjson(
     report: str,
-    dataset: str,
+    dataset: str | UUID,
     report_json: dict,
     theme_json: Optional[dict] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Creates a report based on a report.json file (and an optional themes.json file).
@@ -29,36 +31,27 @@ def create_report_from_reportjson(
     ----------
     report : str
         Name of the report.
-    dataset : str
-        Name of the semantic model to connect to the report.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model to connect to the report.
     report_json : dict
         The report.json file to be used to create the report.
     theme_json : dict, default=None
         The theme.json file to be used for the theme of the report.
-    workspace : str, default=None
-        The Fabric workspace name.
+    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.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    dfI = fabric.list_items(workspace=workspace)
-
-    dfI_model = dfI[(dfI["Display Name"] == dataset) & (dfI["Type"] == "SemanticModel")]
-
-    if len(dfI_model) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model does not exist in the '{workspace}' workspace."
-        )
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
-    datasetId = dfI_model["Id"].iloc[0]
+    dfI = fabric.list_items(workspace=workspace, type="Report")
+    dfI_rpt = dfI[dfI["Display Name"] == report]
 
-    dfI_rpt = dfI[(dfI["Display Name"] == report) & (dfI["Type"] == "Report")]
-
-    if len(dfI_rpt) > 0:
+    if not dfI_rpt.empty:
         print(
-            f"{icons.yellow_dot} '{report}' already exists as a report in the '{workspace}' workspace."
+            f"{icons.yellow_dot} '{report}' report already exists in the '{workspace_name}' workspace."
         )
         return
 
@@ -71,7 +64,7 @@ def create_report_from_reportjson(
                 "connectionString": None,
                 "pbiServiceModelId": None,
                 "pbiModelVirtualServerName": "sobe_wowvirtualserver",
-                "pbiModelDatabaseName": datasetId,
+                "pbiModelDatabaseName": dataset_id,
                 "name": "EntityDataSource",
                 "connectionType": "pbiServiceXmlaStyleLive",
             },
@@ -116,12 +109,12 @@ def create_report_from_reportjson(
     lro(client, response, status_codes=[201, 202], return_status_code=True)
 
     print(
-        f"{icons.green_dot} Succesfully created the '{report}' report within the '{workspace}' workspace."
+        f"{icons.green_dot} Succesfully created the '{report}' report within the '{workspace_name}' workspace."
     )
 
 
 def update_report_from_reportjson(
-    report: str, report_json: dict, workspace: Optional[str] = None
+    report: str, report_json: dict, workspace: Optional[str | UUID] = None
 ):
     """
     Updates a report based on a report.json file.
@@ -134,17 +127,17 @@ def update_report_from_reportjson(
         Name of the report.
     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.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID 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.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-    report_id = resolve_report_id(report=report, workspace=workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    report_id = resolve_report_id(report=report, workspace=workspace_id)
 
     # Get the existing PBIR file
-    df_items = get_report_definition(report=report, workspace=workspace)
+    df_items = get_report_definition(report=report, workspace=workspace_id)
     df_items_filt = df_items[df_items["path"] == "definition.pbir"]
     rptDefFile = df_items_filt["payload"].iloc[0]
     payloadReportJson = _conv_b64(report_json)
@@ -175,12 +168,12 @@ def update_report_from_reportjson(
     lro(client, response, return_status_code=True)
 
     print(
-        f"{icons.green_dot} The '{report}' report within the '{workspace}' workspace has been successfully updated."
+        f"{icons.green_dot} The '{report}' report within the '{workspace_name}' workspace has been successfully updated."
     )
 
 
 def get_report_definition(
-    report: str, workspace: Optional[str] = None, return_dataframe: bool = True
+    report: str, workspace: Optional[str | UUID] = None, return_dataframe: bool = True
 ) -> pd.DataFrame | dict:
     """
     Gets the collection of definition files of a report.
@@ -191,8 +184,8 @@ def get_report_definition(
     ----------
     report : str
         Name of the report.
-    workspace : str, default=None
-        The Fabric workspace name in which the report resides.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID 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.
     return_dataframe : bool, default=True
@@ -204,9 +197,9 @@ def get_report_definition(
         The collection of report definition files within a pandas dataframe.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
-    report_id = resolve_report_id(report=report, workspace=workspace)
+    report_id = resolve_report_id(report=report, workspace=workspace_id)
     client = fabric.FabricRestClient()
     response = client.post(
         f"/v1/workspaces/{workspace_id}/reports/{report_id}/getDefinition",
@@ -224,7 +217,7 @@ def get_report_definition(
 def create_model_bpa_report(
     report: Optional[str] = icons.model_bpa_name,
     dataset: Optional[str] = icons.model_bpa_name,
-    dataset_workspace: Optional[str] = None,
+    dataset_workspace: Optional[str | UUID] = None,
 ):
     """
     Dynamically generates a Best Practice Analyzer report for analyzing semantic models.
@@ -237,24 +230,27 @@ def create_model_bpa_report(
     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.
+    dataset_workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID 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")
+    (dataset_workspace_name, dataset_workspace_id) = resolve_workspace_name_and_id(
+        dataset_workspace
+    )
+
+    dfI = fabric.list_items(workspace=dataset_workspace_id, 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."
+            f"The '{dataset}' semantic model does not exist within the '{dataset_workspace_name}' workspace."
         )
 
-    dfR = fabric.list_reports(workspace=dataset_workspace)
+    dfR = fabric.list_reports(workspace=dataset_workspace_id)
     dfR_filt = dfR[dfR["Name"] == report]
     # dataset_id = resolve_dataset_id(dataset=dataset, workspace=dataset_workspace)
 
@@ -306,14 +302,14 @@ def create_model_bpa_report(
 
     if len(dfR_filt) > 0:
         update_report_from_reportjson(
-            report=report, report_json=report_json, workspace=dataset_workspace
+            report=report, report_json=report_json, workspace=dataset_workspace_id
         )
     else:
         create_report_from_reportjson(
             report=report,
             dataset=dataset,
             report_json=report_json,
-            workspace=dataset_workspace,
+            workspace=dataset_workspace_id,
         )
 
 

sempy_labs/report/_paginated.py

@@ -2,11 +2,15 @@ import sempy.fabric as fabric
 from typing import Optional
 from sempy.fabric.exceptions import FabricHTTPException
 import pandas as pd
+from uuid import UUID
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+)
 
 
 def get_report_datasources(
     report: str,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ) -> pd.DataFrame:
     """
     Returns a list of data sources for the specified paginated report (RDL) from the specified workspace.
@@ -15,8 +19,8 @@ def get_report_datasources(
     ----------
     report : str | List[str]
         Name(s) of the Power BI report(s).
-    workspace : str, default=None
-        The name of the Fabric workspace in which the report resides.
+    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.
 
@@ -38,14 +42,10 @@ def get_report_datasources(
         ]
     )
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
     report_id = fabric.resolve_item_id(
-        item_name=report, type="PaginatedReport", workspace=workspace
+        item_name=report, type="PaginatedReport", workspace=workspace_id
     )
 
     client = fabric.PowerBIRestClient()

sempy_labs/report/_report_bpa.py

@@ -11,18 +11,20 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     resolve_workspace_capacity,
     _get_max_run_id,
+    resolve_workspace_name_and_id,
 )
 from sempy_labs.lakehouse import get_lakehouse_tables, lakehouse_attached
 import sempy_labs._icons as icons
 from IPython.display import display, HTML
 import sempy_labs.report._report_helper as helper
+from uuid import UUID
 
 
 @log
 def run_report_bpa(
     report: str,
     rules: Optional[pd.DataFrame] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     # language: Optional[str] = None,
     export: bool = False,
     return_dataframe: bool = False,
@@ -37,8 +39,8 @@ def run_report_bpa(
         Name of the report.
     rules : pandas.DataFrame, default=None
         A pandas dataframe containing rules to be evaluated.
-    workspace : str, default=None
-        The Fabric workspace name.
+    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.
     export : bool, default=False
@@ -52,7 +54,9 @@ def run_report_bpa(
         A pandas dataframe in HTML format showing report objects which violated the best practice analyzer rules.
     """
 
-    rpt = ReportWrapper(report=report, workspace=workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    rpt = ReportWrapper(report=report, workspace=workspace_id)
 
     dfCV = rpt.list_custom_visuals()
     dfP = rpt.list_pages()
@@ -145,7 +149,7 @@ def run_report_bpa(
             df_output["Description"] = row["Description"]
             df_output["URL"] = row["URL"]
             df_output["Report URL"] = helper.get_web_url(
-                report=report, workspace=workspace
+                report=report, workspace=workspace_id
             )
 
             page_mapping_dict = dfP.set_index("Page Display Name")["Page URL"].to_dict()
@@ -219,13 +223,13 @@ def run_report_bpa(
             runId = max_run_id + 1
 
         export_df = finalDF.copy()
-        capacity_id, capacity_name = resolve_workspace_capacity(workspace=workspace)
+        capacity_id, capacity_name = resolve_workspace_capacity(workspace=workspace_id)
         export_df["Capacity Name"] = capacity_name
         export_df["Capacity Id"] = capacity_id
-        export_df["Workspace Name"] = workspace
-        export_df["Workspace Id"] = fabric.resolve_workspace_id(workspace)
+        export_df["Workspace Name"] = workspace_name
+        export_df["Workspace Id"] = workspace_id
         export_df["Report Name"] = report
-        export_df["Report Id"] = resolve_report_id(report, workspace)
+        export_df["Report Id"] = resolve_report_id(report, workspace_id)
         export_df["RunId"] = runId
         export_df["Timestamp"] = now
         export_df["RunId"] = export_df["RunId"].astype(int)