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

sempy_labs/admin/_basic_functions.py

@@ -27,9 +27,9 @@ def list_workspaces(
 
     Parameters
     ----------
-    capacity : str | UUID, default=None
+    capacity : str | uuid.UUID, default=None
         Returns only the workspaces in the specified Capacity.
-    workspace : str | UUID, default=None
+    workspace : str | uuid.UUID, default=None
         Returns the workspace with the specific name.
     workspace_state : str, default=None
         Return only the workspace with the requested state. You can find the possible states in `Workspace States <https://learn.microsoft.com/en-us/rest/api/fabric/admin/workspaces/list-workspaces?tabs=HTTP#workspacestate>`_.
@@ -131,7 +131,7 @@ def list_capacities(
 
     Parameters
     ----------
-    capacity : str | UUID, default=None
+    capacity : str | uuid.UUID, default=None
         Capacity name or id to filter.
 
     Returns
@@ -185,11 +185,11 @@ def assign_workspaces_to_capacity(
 
     Parameters
     ----------
-    source_capacity : str | UUID, default=None
+    source_capacity : str | uuid.UUID, default=None
         The name of the source capacity. If the Workspace is not specified, this is parameter mandatory.
-    target_capacity : str | UUID, default=None
+    target_capacity : str | uuid.UUID, default=None
         The name of the target capacity.
-    workspace : str | List[str] | UUID | List[UUID], default=None
+    workspace : str | List[str] | uuid.UUID | List[uuid.UUID], default=None
         The name or id of the workspace(s).
         Defaults to None which resolves to migrating all workspaces within the source capacity to the target capacity.
     """
@@ -274,7 +274,7 @@ def unassign_workspaces_from_capacity(
 
     Parameters
     ----------
-    workspaces : str | List[str] | UUID | List[UUID]
+    workspaces : str | List[str] | uuid.UUID | List[uuid.UUID]
         The Fabric workspace name(s) or id(s).
     """
     if isinstance(workspaces, str):
@@ -512,8 +512,6 @@ def list_datasets(
         Returns a subset of a results based on Odata filter query parameter condition.
     skip : int, default=None
         Skips the first n results.
-    token_provider : Optional[TokenProvider] = None,
-        Authentication provider used to be use in the request. Supports Service Principal.
 
     Returns
     -------
@@ -673,7 +671,7 @@ def list_workspace_access_details(
 
     Parameters
     ----------
-    workspace : str | UUID, default=None
+    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.
@@ -721,7 +719,7 @@ def list_activity_events(
     end_time: str,
     activity_filter: Optional[str] = None,
     user_id_filter: Optional[str] = None,
-    return_dataframe: Optional[bool] = True,
+    return_dataframe: bool = True,
 ) -> pd.DataFrame | dict:
     """
     Shows a list of audit activity events for a tenant.
@@ -777,6 +775,23 @@ def list_activity_events(
             "Object Display Name",
             "Experience",
             "Refresh Enforcement Policy",
+            "Is Success",
+            "Activity Id",
+            "Item Name",
+            "Dataset Name",
+            "Report Name",
+            "Capacity Id",
+            "Capacity Name",
+            "App Name",
+            "Dataset Id",
+            "Report Id",
+            "Artifact Id",
+            "Artifact Name",
+            "Report Type",
+            "App Report Id",
+            "Distribution Method",
+            "Consumption Method",
+            "Artifact Kind",
         ]
     )
 
@@ -825,6 +840,23 @@ def list_activity_events(
                     "Object Display Name": i.get("ObjectDisplayName"),
                     "Experience": i.get("Experience"),
                     "Refresh Enforcement Policy": i.get("RefreshEnforcementPolicy"),
+                    "Is Success": i.get("IsSuccess"),
+                    "Activity Id": i.get("ActivityId"),
+                    "Item Name": i.get("ItemName"),
+                    "Dataset Name": i.get("DatasetName"),
+                    "Report Name": i.get("ReportName"),
+                    "Capacity Id": i.get("CapacityId"),
+                    "Capacity Name": i.get("CapacityName"),
+                    "App Name": i.get("AppName"),
+                    "Dataset Id": i.get("DatasetId"),
+                    "Report Id": i.get("ReportId"),
+                    "Artifact Id": i.get("ArtifactId"),
+                    "Artifact Name": i.get("ArtifactName"),
+                    "Report Type": i.get("ReportType"),
+                    "App Report Id": i.get("AppReportId"),
+                    "Distribution Method": i.get("DistributionMethod"),
+                    "Consumption Method": i.get("ConsumptionMethod"),
+                    "Artifact Kind": i.get("ArtifactKind"),
                 }
                 df = pd.concat(
                     [df, pd.DataFrame(new_data, index=[0])],
@@ -1003,7 +1035,7 @@ def get_capacity_assignment_status(workspace: Optional[str | UUID] = None):
 
     Parameters
     ----------
-    workspace : str | UUID, default=None
+    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.

sempy_labs/admin/_external_data_share.py

@@ -75,11 +75,11 @@ def revoke_external_data_share(
 
     Parameters
     ----------
-    external_data_share_id : UUID
+    external_data_share_id : uuid.UUID
         The external data share ID.
-    item_id : int, default=None
+    item_id : uuid.UUID, default=None
         The Item ID
-    workspace : str
+    workspace : str | uuid.UUID
         The Fabric workspace name or id.
     """
     (workspace, workspace_id) = _resolve_workspace_name_and_id(workspace)

sempy_labs/admin/_items.py

@@ -65,7 +65,7 @@ def _resolve_item_name_and_id(
 
 def list_items(
     capacity: Optional[str | UUID] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     state: Optional[str] = None,
     type: Optional[str] = None,
     item: Optional[str | UUID] = None,
@@ -78,9 +78,9 @@ def list_items(
 
     Parameters
     ----------
-    capacity : str | UUID, default=None
+    capacity : str | uuid.UUID, default=None
         The capacity name or id.
-    workspace : str, default=None
+    workspace : str | uuid.UUID, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
@@ -195,7 +195,7 @@ def list_item_access_details(
         Name or id of the Fabric item.
     type : str, default=None
         Type of Fabric item.
-    workspace : str, default=None
+    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.

sempy_labs/admin/_scanner.py

@@ -5,8 +5,10 @@ from sempy.fabric.exceptions import FabricHTTPException
 import numpy as np
 import time
 from sempy_labs.admin._basic_functions import list_workspaces
+from sempy._utils._log import log
 
 
+@log
 def scan_workspaces(
     data_source_details: bool = False,
     dataset_schema: bool = False,
@@ -16,12 +18,12 @@ def scan_workspaces(
     workspace: Optional[str | List[str] | UUID | List[UUID]] = None,
 ) -> dict:
     """
-    Get the inventory and details of the tenant.
+    Gets the scan result for the specified scan.
 
     This is a wrapper function for the following APIs:
-        `Admin - WorkspaceInfo PostWorkspaceInfo <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-post-workspace-info>`_.
-        `Admin - WorkspaceInfo GetScanStatus <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-get-scan-status>`_.
-        `Admin - WorkspaceInfo GetScanResult <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-get-scan-result>`_.
+        `Admin - WorkspaceInfo PostWorkspaceInfo <https://learn.microsoft.com/rest/api/power-bi/admin/workspace-info-post-workspace-info>`_.
+        `Admin - WorkspaceInfo GetScanStatus <https://learn.microsoft.com/rest/api/power-bi/admin/workspace-info-get-scan-status>`_.
+        `Admin - WorkspaceInfo GetScanResult <https://learn.microsoft.com/rest/api/power-bi/admin/workspace-info-get-scan-result>`_.
 
     Parameters
     ----------
@@ -35,7 +37,7 @@ def scan_workspaces(
         Whether to return lineage info (upstream dataflows, tiles, data source IDs)
     artifact_users : bool, default=False
         Whether to return user details for a Power BI item (such as a report or a dashboard)
-    workspace : str | List[str] | UUID | List[UUID], default=None
+    workspace : str | List[str] | uuid.UUID | List[uuid.UUID], default=None
         The required workspace name(s) or id(s) to be scanned
 
     Returns

sempy_labs/directlake/_directlake_schema_compare.py

@@ -2,6 +2,8 @@ import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._helper_functions import (
     format_dax_object_name,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
 )
 from IPython.display import display
 from sempy_labs.lakehouse import get_lakehouse_columns
@@ -9,12 +11,13 @@ from sempy_labs.directlake._dl_helper import get_direct_lake_source
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy._utils._log import log
+from uuid import UUID
 
 
 @log
 def direct_lake_schema_compare(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     **kwargs,
 ):
     """
@@ -22,10 +25,10 @@ def direct_lake_schema_compare(
 
     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.
     """
@@ -41,10 +44,11 @@ def direct_lake_schema_compare(
         )
         del kwargs["lakehouse_workspace"]
 
-    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)
 
     artifact_type, lakehouse_name, lakehouse_id, lakehouse_workspace_id = (
-        get_direct_lake_source(dataset=dataset, workspace=workspace)
+        get_direct_lake_source(dataset=dataset_id, workspace=workspace_id)
     )
     lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
 
@@ -53,15 +57,15 @@ def direct_lake_schema_compare(
             f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
         )
 
-    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+    dfP = fabric.list_partitions(dataset=dataset_id, workspace=workspace_id)
 
     if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode."
+            f"{icons.red_dot} The '{dataset_name}' semantic model within the '{workspace_name}' workspace is not in Direct Lake mode."
         )
 
-    dfT = fabric.list_tables(dataset=dataset, workspace=workspace)
-    dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
+    dfT = fabric.list_tables(dataset=dataset_id, workspace=workspace_id)
+    dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id)
     lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)
 
     dfT.rename(columns={"Type": "Table Type"}, inplace=True)
@@ -92,7 +96,7 @@ def direct_lake_schema_compare(
         )
     else:
         print(
-            f"{icons.yellow_dot} The following tables exist in the '{dataset}' semantic model within the '{workspace}' workspace"
+            f"{icons.yellow_dot} The following tables exist in the '{dataset_name}' semantic model within the '{workspace_name}' workspace"
             f" but do not exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingtbls)
@@ -102,7 +106,7 @@ def direct_lake_schema_compare(
         )
     else:
         print(
-            f"{icons.yellow_dot} The following columns exist in the '{dataset}' semantic model within the '{workspace}' workspace "
+            f"{icons.yellow_dot} The following columns exist in the '{dataset_name}' semantic model within the '{workspace_name}' workspace "
             f"but do not exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingcols)

sempy_labs/directlake/_directlake_schema_sync.py

@@ -3,16 +3,21 @@ import sempy.fabric as fabric
 from sempy_labs.lakehouse import get_lakehouse_columns
 from sempy_labs.directlake._dl_helper import get_direct_lake_source
 from sempy_labs.tom import connect_semantic_model
-from sempy_labs._helper_functions import _convert_data_type
+from sempy_labs._helper_functions import (
+    _convert_data_type,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+)
 from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 @log
 def direct_lake_schema_sync(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     add_to_model: bool = False,
     **kwargs,
 ):
@@ -21,10 +26,10 @@ def direct_lake_schema_sync(
 
     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.
     add_to_model : bool, default=False
@@ -45,10 +50,11 @@ def direct_lake_schema_sync(
         )
         del kwargs["lakehouse_workspace"]
 
-    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)
 
     artifact_type, lakehouse_name, lakehouse_id, lakehouse_workspace_id = (
-        get_direct_lake_source(dataset=dataset, workspace=workspace)
+        get_direct_lake_source(dataset=dataset_id, workspace=workspace_id)
     )
 
     if artifact_type == "Warehouse":
@@ -60,7 +66,7 @@ def direct_lake_schema_sync(
     lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)
 
     with connect_semantic_model(
-        dataset=dataset, readonly=False, workspace=workspace
+        dataset=dataset_id, readonly=False, workspace=workspace_id
     ) as tom:
 
         for i, r in lc.iterrows():
@@ -86,7 +92,7 @@ def direct_lake_schema_sync(
                     for c in tom.all_columns()
                 ):
                     print(
-                        f"{icons.yellow_dot} The '{lakeCName}' column exists in the '{lakeTName}' lakehouse table but not in the '{dataset}' semantic model within the '{workspace}' workspace."
+                        f"{icons.yellow_dot} The '{lakeCName}' column exists in the '{lakeTName}' lakehouse table but not in the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
                     )
                     if add_to_model:
                         dt = _convert_data_type(dType)
@@ -97,5 +103,5 @@ def direct_lake_schema_sync(
                             data_type=dt,
                         )
                         print(
-                            f"{icons.green_dot} The '{lakeCName}' column in the '{lakeTName}' lakehouse table was added to the '{dataset}' semantic model within the '{workspace}' workspace."
+                            f"{icons.green_dot} The '{lakeCName}' column in the '{lakeTName}' lakehouse table was added to the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
                         )

sempy_labs/directlake/_dl_helper.py

@@ -7,24 +7,25 @@ import sempy_labs._icons as icons
 from sempy._utils._log import log
 from sempy_labs._helper_functions import (
     retry,
-    resolve_dataset_id,
     resolve_lakehouse_name,
     _convert_data_type,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
 )
 
 
 def check_fallback_reason(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> pd.DataFrame:
     """
     Shows the reason a table in a Direct Lake semantic model would fallback to DirectQuery.
 
     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.
 
@@ -35,19 +36,22 @@ def check_fallback_reason(
     """
     from sempy_labs.tom import connect_semantic_model
 
-    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=workspace_id
+    )
 
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=True
+        dataset=dataset_id, workspace=workspace_id, readonly=True
     ) as tom:
         if not tom.is_direct_lake():
             raise ValueError(
-                f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
+                f"{icons.red_dot} The '{dataset_name}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
             )
 
     df = fabric.evaluate_dax(
-        dataset=dataset,
-        workspace=workspace,
+        dataset=dataset_id,
+        workspace=workspace_id,
         dax_string="""
             SELECT [TableName] AS [Table Name],[FallbackReason] AS [FallbackReasonID]
             FROM $SYSTEM.TMSCHEMA_DELTA_TABLE_METADATA_STORAGES
@@ -76,9 +80,9 @@ def check_fallback_reason(
 def generate_direct_lake_semantic_model(
     dataset: str,
     lakehouse_tables: Union[str, List[str]],
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
     schema: str = "dbo",
     overwrite: bool = False,
     refresh: bool = True,
@@ -92,15 +96,15 @@ def generate_direct_lake_semantic_model(
         Name of the semantic model to be created.
     lakehouse_tables : str | List[str]
         The table(s) within the Fabric lakehouse to add to the semantic model. All columns from these tables will be added to the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name in which the semantic model will reside.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model will reside.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     lakehouse : str, default=None
         The lakehouse which stores the delta tables which will feed the Direct Lake semantic model.
         Defaults to None which resolves to the attached lakehouse.
-    lakehouse_workspace : str, default=None
-        The Fabric workspace in which the lakehouse resides.
+    lakehouse_workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the 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.
     schema : str, default="dbo"
@@ -122,7 +126,7 @@ def generate_direct_lake_semantic_model(
     if isinstance(lakehouse_tables, str):
         lakehouse_tables = [lakehouse_tables]
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     if lakehouse_workspace is None:
         lakehouse_workspace = workspace
     if lakehouse is None:
@@ -139,23 +143,23 @@ def generate_direct_lake_semantic_model(
     for t in lakehouse_tables:
         if t not in dfLT["Table Name"].values:
             raise ValueError(
-                f"{icons.red_dot} The '{t}' table does not exist as a delta table in the '{lakehouse}' within the '{workspace}' workspace."
+                f"{icons.red_dot} The '{t}' table does not exist as a delta table in the '{lakehouse}' within the '{workspace_name}' workspace."
             )
 
     dfLC = get_lakehouse_columns(lakehouse=lakehouse, workspace=lakehouse_workspace)
     expr = generate_shared_expression(
         item_name=lakehouse, item_type="Lakehouse", workspace=lakehouse_workspace
     )
-    dfD = fabric.list_datasets(workspace=workspace)
+    dfD = fabric.list_datasets(workspace=workspace_id)
     dfD_filt = dfD[dfD["Dataset Name"] == dataset]
 
     if len(dfD_filt) > 0 and not overwrite:
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace already exists. Overwrite is set to False so the new semantic model has not been created."
+            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace_name}' workspace already exists. Overwrite is set to False so the new semantic model has not been created."
         )
 
     create_blank_semantic_model(
-        dataset=dataset, workspace=workspace, overwrite=overwrite
+        dataset=dataset, workspace=workspace_id, overwrite=overwrite
     )
 
     @retry(
@@ -164,7 +168,7 @@ def generate_direct_lake_semantic_model(
     )
     def dyn_connect():
         with connect_semantic_model(
-            dataset=dataset, readonly=True, workspace=workspace
+            dataset=dataset, readonly=True, workspace=workspace_id
         ) as tom:
 
             tom.model
@@ -173,7 +177,7 @@ def generate_direct_lake_semantic_model(
 
     expression_name = "DatabaseQuery"
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=False
+        dataset=dataset, workspace=workspace_id, readonly=False
     ) as tom:
         if not any(e.Name == expression_name for e in tom.model.Expressions):
             tom.add_expression(name=expression_name, expression=expr)
@@ -194,21 +198,21 @@ def generate_direct_lake_semantic_model(
                 )
 
     if refresh:
-        refresh_semantic_model(dataset=dataset, workspace=workspace)
+        refresh_semantic_model(dataset=dataset, workspace=workspace_id)
 
 
 def get_direct_lake_source(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> Tuple[str, str, UUID, UUID]:
     """
     Obtains the source information for a direct lake semantic model.
 
     Parameters
     ----------
-    dataset : str
-        The name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    dataset : str | uuid.UUID
+        The 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.
 
@@ -220,8 +224,8 @@ def get_direct_lake_source(
         If the semantic model is not a Direct Lake semantic model, it will return None, None, None.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    dataset_id = resolve_dataset_id(dataset, workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
     client = fabric.PowerBIRestClient()
     request_body = {
         "artifacts": [

sempy_labs/directlake/_generate_shared_expression.py

@@ -3,16 +3,18 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     resolve_lakehouse_id,
     resolve_warehouse_id,
+    resolve_workspace_name_and_id,
 )
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
+from uuid import UUID
 
 
 def generate_shared_expression(
     item_name: Optional[str] = None,
     item_type: str = "Lakehouse",
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ) -> str:
     """
     Dynamically generates the M expression used by a Direct Lake model for a given lakehouse/warehouse.
@@ -24,8 +26,8 @@ def generate_shared_expression(
         Defaults to None which resolves to the lakehouse attached to the notebook.
     item_type : str, default="Lakehouse"
         The Fabric item name. Valid options: 'Lakehouse', 'Warehouse'.
-    workspace : str, default=None
-        The Fabric workspace used by the item.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the item.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -35,8 +37,7 @@ def generate_shared_expression(
         Shows the expression which can be used to connect a Direct Lake semantic model to its SQL Endpoint.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    workspace_id = fabric.resolve_workspace_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     item_types = ["Lakehouse", "Warehouse"]
     item_type = item_type.capitalize()
     if item_type not in item_types:
@@ -46,11 +47,11 @@ def generate_shared_expression(
 
     if item_name is None:
         item_id = fabric.get_lakehouse_id()
-        item_name = resolve_lakehouse_name(item_id, workspace)
+        item_name = resolve_lakehouse_name(item_id, workspace_id)
     elif item_name is not None and item_type == "Lakehouse":
-        item_id = resolve_lakehouse_id(lakehouse=item_name, workspace=workspace)
+        item_id = resolve_lakehouse_id(lakehouse=item_name, workspace=workspace_id)
     elif item_type == "Warehouse":
-        item_id = resolve_warehouse_id(warehouse=item_name, workspace=workspace)
+        item_id = resolve_warehouse_id(warehouse=item_name, workspace=workspace_id)
 
     client = fabric.FabricRestClient()
     item_type_rest = f"{item_type.lower()}s"
@@ -72,7 +73,7 @@ def generate_shared_expression(
 
     if provStatus == "InProgress":
         raise ValueError(
-            f"{icons.red_dot} The SQL Endpoint for the '{item_name}' lakehouse within the '{workspace}' workspace has not yet been provisioned. Please wait until it has been provisioned."
+            f"{icons.red_dot} The SQL Endpoint for the '{item_name}' lakehouse within the '{workspace_name}' workspace has not yet been provisioned. Please wait until it has been provisioned."
         )
 
     start_expr = "let\n\tdatabase = "