semantic-link-labs 0.8.10__py3-none-any.whl → 0.9.0__py3-none-any.whl

sempy_labs/lakehouse/_shortcuts.py

@@ -7,14 +7,15 @@ from sempy_labs._helper_functions import (
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
+from uuid import UUID
 
 
 def create_shortcut_onelake(
     table_name: str,
     source_lakehouse: str,
-    source_workspace: str,
+    source_workspace: str | UUID,
     destination_lakehouse: str,
-    destination_workspace: Optional[str] = None,
+    destination_workspace: Optional[str | UUID] = None,
     shortcut_name: Optional[str] = None,
 ):
     """
@@ -28,28 +29,44 @@ def create_shortcut_onelake(
         The table name for which a shortcut will be created.
     source_lakehouse : str
         The Fabric lakehouse in which the table resides.
-    source_workspace : str
-        The name of the Fabric workspace in which the source lakehouse exists.
+    source_workspace : str | uuid.UUID
+        The name or ID of the Fabric workspace in which the source lakehouse exists.
     destination_lakehouse : str
         The Fabric lakehouse in which the shortcut will be created.
-    destination_workspace : str, default=None
-        The name of the Fabric workspace in which the shortcut will be created.
+    destination_workspace : str | uuid.UUID, default=None
+        The name or ID of the Fabric workspace in which the shortcut will be created.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     shortcut_name : str, default=None
         The name of the shortcut 'table' to be created. This defaults to the 'table_name' parameter value.
     """
 
-    sourceWorkspaceId = fabric.resolve_workspace_id(source_workspace)
-    sourceLakehouseId = resolve_lakehouse_id(source_lakehouse, source_workspace)
+    (source_workspace_name, source_workspace_id) = resolve_workspace_name_and_id(
+        source_workspace
+    )
+    source_lakehouse_id = resolve_lakehouse_id(source_lakehouse, source_workspace_id)
+    source_lakehouse_name = fabric.resolve_item_name(
+        item_id=source_lakehouse_id, type="Lakehouse", workspace=source_workspace_id
+    )
 
     if destination_workspace is None:
-        destination_workspace = source_workspace
+        destination_workspace_name = source_workspace_name
+        destination_workspace_id = source_workspace_id
+    else:
+        destination_workspace_name = destination_workspace
+        destination_workspace_id = fabric.resolve_workspace_id(
+            destination_workspace_name
+        )
 
-    destinationWorkspaceId = fabric.resolve_workspace_id(destination_workspace)
-    destinationLakehouseId = resolve_lakehouse_id(
+    destination_workspace_id = fabric.resolve_workspace_id(destination_workspace)
+    destination_lakehouse_id = resolve_lakehouse_id(
         destination_lakehouse, destination_workspace
     )
+    destination_lakehouse_name = fabric.resolve_item_name(
+        item_id=destination_lakehouse_id,
+        type="Lakehouse",
+        workspace=destination_workspace_id,
+    )
 
     if shortcut_name is None:
         shortcut_name = table_name
@@ -62,8 +79,8 @@ def create_shortcut_onelake(
         "name": shortcut_name.replace(" ", ""),
         "target": {
             "oneLake": {
-                "workspaceId": sourceWorkspaceId,
-                "itemId": sourceLakehouseId,
+                "workspaceId": source_workspace_id,
+                "itemId": source_lakehouse_id,
                 "path": tablePath,
             }
         },
@@ -71,13 +88,13 @@ def create_shortcut_onelake(
 
     try:
         response = client.post(
-            f"/v1/workspaces/{destinationWorkspaceId}/items/{destinationLakehouseId}/shortcuts",
+            f"/v1/workspaces/{destination_workspace_id}/items/{destination_lakehouse_id}/shortcuts",
             json=request_body,
         )
         if response.status_code == 201:
             print(
-                f"{icons.green_dot} The shortcut '{shortcut_name}' was created in the '{destination_lakehouse}' lakehouse within"
-                f" the '{destination_workspace} workspace. It is based on the '{table_name}' table in the '{source_lakehouse}' lakehouse within the '{source_workspace}' workspace."
+                f"{icons.green_dot} The shortcut '{shortcut_name}' was created in the '{destination_lakehouse_name}' lakehouse within"
+                f" the '{destination_workspace_name} workspace. It is based on the '{table_name}' table in the '{source_lakehouse_name}' lakehouse within the '{source_workspace_name}' workspace."
             )
         else:
             print(response.status_code)
@@ -166,7 +183,9 @@ def create_shortcut(
 
 
 def delete_shortcut(
-    shortcut_name: str, lakehouse: Optional[str] = None, workspace: Optional[str] = None
+    shortcut_name: str,
+    lakehouse: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Deletes a shortcut.
@@ -180,19 +199,19 @@ def delete_shortcut(
     lakehouse : str, default=None
         The Fabric lakehouse name in which the shortcut resides.
         Defaults to None which resolves to the lakehouse attached to the notebook.
-    workspace : str, default=None
-        The name of the Fabric workspace in which lakehouse resides.
+    workspace : str | UUID, default=None
+        The name or ID of the Fabric workspace in which lakehouse 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)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
     if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, workspace)
+        lakehouse = resolve_lakehouse_name(lakehouse_id, workspace_id)
     else:
-        lakehouse_id = resolve_lakehouse_id(lakehouse, workspace)
+        lakehouse_id = resolve_lakehouse_id(lakehouse, workspace_id)
 
     client = fabric.FabricRestClient()
     response = client.delete(
@@ -202,5 +221,5 @@ def delete_shortcut(
     if response.status_code != 200:
         raise FabricHTTPException(response)
     print(
-        f"{icons.green_dot} The '{shortcut_name}' shortcut in the '{lakehouse}' within the '{workspace}' workspace has been deleted."
+        f"{icons.green_dot} The '{shortcut_name}' shortcut in the '{lakehouse}' within the '{workspace_name}' workspace has been deleted."
     )

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,22 @@ from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     _conv_b64,
     resolve_report_id,
+    resolve_dataset_name_and_id,
+    resolve_item_name_and_id,
     lro,
 )
 import sempy_labs._icons as icons
 from sempy._utils._log import log
+from uuid import UUID
+from sempy.fabric.exceptions import FabricHTTPException
 
 
 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 +33,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 +66,7 @@ def create_report_from_reportjson(
                 "connectionString": None,
                 "pbiServiceModelId": None,
                 "pbiModelVirtualServerName": "sobe_wowvirtualserver",
-                "pbiModelDatabaseName": datasetId,
+                "pbiModelDatabaseName": dataset_id,
                 "name": "EntityDataSource",
                 "connectionType": "pbiServiceXmlaStyleLive",
             },
@@ -116,12 +111,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 +129,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 +170,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 +186,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 +199,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 +219,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 +232,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 +304,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,
         )
 
 
@@ -375,3 +373,46 @@ def _create_report(
             report_workspace=report_workspace,
             dataset_workspace=dataset_workspace,
         )
+
+
+def _get_report(
+    report: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (report_name, report_id) = resolve_item_name_and_id(
+        item=report, type="Report", workspace=workspace
+    )
+
+    client = fabric.FabricRestClient()
+    response = client.get(f"/v1.0/myorg/groups/{workspace_id}/reports/{report_id}")
+
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    result = response.json()
+
+    new_data = {
+        "Id": result.get("id"),
+        "Report Type": result.get("reportType"),
+        "Name": result.get("name"),
+        "Web Url": result.get("webUrl"),
+        "Embed Url": result.get("embedUrl"),
+        "Is From Pbix": result.get("isFromPbix"),
+        "Is Owned By Me": result.get("isOwnedByMe"),
+        "Dataset Id": result.get("datasetId"),
+        "Dataset Workspace Id": result.get("datasetWorkspaceId"),
+        "Users": result.get("users") if result.get("users") is not None else [],
+        "Subscriptions": (
+            result.get("subscriptions")
+            if result.get("subscriptions") is not None
+            else []
+        ),
+    }
+
+    df = pd.DataFrame([new_data])
+
+    bool_cols = ["Is From Pbix", "Is Owned By Me"]
+    df[bool_cols] = df[bool_cols].astype(bool)
+
+    return df

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()