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

sempy_labs/directlake/_dl_helper.py

@@ -7,7 +7,6 @@ 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,
@@ -16,17 +15,17 @@ from sempy_labs._helper_functions import (
 
 
 def check_fallback_reason(
-    dataset: str | UUID, 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 | UUID
+    dataset : str | uuid.UUID
         Name or ID of the semantic model.
-    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.
 
@@ -81,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,
@@ -97,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"
@@ -127,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:
@@ -144,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(
@@ -169,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
@@ -178,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)
@@ -199,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.
 
@@ -225,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 = "

sempy_labs/directlake/_get_directlake_lakehouse.py

@@ -3,46 +3,49 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_id,
     resolve_lakehouse_name,
     get_direct_lake_sql_endpoint,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
 )
 from typing import Optional, Tuple
 from uuid import UUID
 
 
 def get_direct_lake_lakehouse(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
 ) -> Tuple[str, UUID]:
     """
     Identifies the lakehouse used by a Direct Lake semantic model.
 
     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.
     lakehouse : str, default=None
         The Fabric lakehouse used by the Direct Lake semantic model.
         Defaults to None which resolves to the lakehouse attached to the notebook.
-    lakehouse_workspace : str, default=None
-        The Fabric workspace used by the lakehouse.
+    lakehouse_workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
         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
     -------
-    str, uuid.UUID
+    Tuple[str, uuid.UUID]
         The lakehouse name and lakehouse ID.
     """
 
-    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)
 
     if lakehouse_workspace is None:
-        lakehouse_workspace = workspace
+        lakehouse_workspace = workspace_name
 
     if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
@@ -56,7 +59,7 @@ def get_direct_lake_lakehouse(
     #        f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode."
     #    )
 
-    sqlEndpointId = get_direct_lake_sql_endpoint(dataset, workspace)
+    sqlEndpointId = get_direct_lake_sql_endpoint(dataset_id, workspace_id)
 
     dfI = fabric.list_items(workspace=lakehouse_workspace, type="SQLEndpoint")
     dfI_filt = dfI[dfI["Id"] == sqlEndpointId]

sempy_labs/directlake/_get_shared_expression.py

@@ -1,8 +1,9 @@
 from typing import Optional
+from uuid import UUID
 
 
 def get_shared_expression(
-    lakehouse: Optional[str] = None, workspace: Optional[str] = None
+    lakehouse: Optional[str] = None, workspace: Optional[str | UUID] = None
 ) -> str:
     """
     Dynamically generates the M expression used by a Direct Lake model for a given lakehouse.
@@ -12,8 +13,8 @@ def get_shared_expression(
     lakehouse : str, default=None
         The Fabric lakehouse used by the Direct Lake semantic model.
         Defaults to None which resolves to the lakehouse attached to the notebook.
-    workspace : str, default=None
-        The Fabric workspace used by the lakehouse.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
         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/directlake/_guardrails.py

@@ -2,6 +2,10 @@ import sempy.fabric as fabric
 import pandas as pd
 from typing import Optional
 import sempy_labs._icons as icons
+from uuid import UUID
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+)
 
 
 def get_direct_lake_guardrails() -> pd.DataFrame:
@@ -28,14 +32,14 @@ def get_direct_lake_guardrails() -> pd.DataFrame:
     return df
 
 
-def get_sku_size(workspace: Optional[str] = None) -> str:
+def get_sku_size(workspace: Optional[str | UUID] = None) -> str:
     """
     Shows the SKU size for a workspace.
 
     Parameters
     ----------
-    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.
 
@@ -45,12 +49,14 @@ def get_sku_size(workspace: Optional[str] = None) -> str:
         The SKU size for a workspace.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
-    dfW = fabric.list_workspaces(filter=f"name eq '{workspace}'")
+    dfW = fabric.list_workspaces(filter=f"id eq '{workspace_id}'")
 
     if len(dfW) == 0:
-        raise ValueError(f"{icons.red_dot} The '{workspace}' is not a valid workspace.")
+        raise ValueError(
+            f"{icons.red_dot} The '{workspace_name}' is not a valid workspace."
+        )
 
     capacity_id = dfW["Capacity Id"].iloc[0]
     dfC = fabric.list_capacities()

sempy_labs/directlake/_list_directlake_model_calc_tables.py

@@ -5,21 +5,26 @@ 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_dataset_name_and_id,
+    resolve_workspace_name_and_id,
+)
 
 
 @log
 def list_direct_lake_model_calc_tables(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> pd.DataFrame:
     """
     Shows the calculated tables and their respective DAX expression for a Direct Lake model (which has been migrated from import/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.
 
@@ -29,12 +34,13 @@ def list_direct_lake_model_calc_tables(
         A pandas dataframe showing the calculated tables which were migrated to Direct Lake and whose DAX expressions are stored as model annotations.
     """
 
-    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)
 
     df = pd.DataFrame(columns=["Table Name", "Source Expression"])
 
     with connect_semantic_model(
-        dataset=dataset, readonly=True, workspace=workspace
+        dataset=dataset_id, readonly=True, workspace=workspace_id
     ) as tom:
 
         is_direct_lake = tom.is_direct_lake()
@@ -44,8 +50,8 @@ def list_direct_lake_model_calc_tables(
                 f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode."
             )
         else:
-            dfA = fabric.list_annotations(dataset=dataset, workspace=workspace)
-            dfT = list_tables(dataset, workspace)
+            dfA = fabric.list_annotations(dataset=dataset_id, workspace=workspace_id)
+            dfT = list_tables(dataset_id, workspace_id)
             dfA_filt = dfA[
                 (dfA["Object Type"] == "Model")
                 & (dfA["Annotation Name"].isin(dfT["Name"]))

sempy_labs/directlake/_show_unsupported_directlake_objects.py

@@ -1,13 +1,18 @@
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs._helper_functions import format_dax_object_name
+from sempy_labs._helper_functions import (
+    format_dax_object_name,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
+)
 from typing import Optional, Tuple
 from sempy._utils._log import log
+from uuid import UUID
 
 
 @log
 def show_unsupported_direct_lake_objects(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
     """
     Returns a list of a semantic model's objects which are not supported by Direct Lake based on
@@ -15,10 +20,10 @@ def show_unsupported_direct_lake_objects(
 
     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.
 
@@ -30,11 +35,12 @@ def show_unsupported_direct_lake_objects(
 
     pd.options.mode.chained_assignment = None
 
-    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)
 
-    dfT = fabric.list_tables(dataset=dataset, workspace=workspace)
-    dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
-    dfR = fabric.list_relationships(dataset=dataset, workspace=workspace)
+    dfT = fabric.list_tables(dataset=dataset_id, workspace=workspace_id)
+    dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id)
+    dfR = fabric.list_relationships(dataset=dataset_id, workspace=workspace_id)
 
     # Calc tables
     dfT_filt = dfT[dfT["Type"] == "Calculated Table"]

sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py

@@ -2,42 +2,46 @@ import sempy.fabric as fabric
 from sempy_labs.directlake._generate_shared_expression import generate_shared_expression
 from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
 )
 from sempy_labs.tom import connect_semantic_model
 from typing import Optional
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 def update_direct_lake_model_lakehouse_connection(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
 ):
     """
     Remaps a Direct Lake semantic model's SQL Endpoint connection to a new lakehouse.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name in which the semantic model exists.
+    dataset : str | UUID
+        Name or ID of the semantic model.
+    workspace : str | UUID, default=None
+        The Fabric workspace name or ID in which the semantic model 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.
     lakehouse : str, default=None
         The Fabric lakehouse used by the Direct Lake semantic model.
         Defaults to None which resolves to the lakehouse attached to the notebook.
-    lakehouse_workspace : str, default=None
-        The Fabric workspace used by the lakehouse.
+    lakehouse_workspace : str | UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
         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 = 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)
 
     if lakehouse_workspace is None:
-        lakehouse_workspace = workspace
+        lakehouse_workspace = workspace_name
 
     if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
@@ -50,7 +54,7 @@ def update_direct_lake_model_lakehouse_connection(
     if len(dfI_filt) == 0:
         raise ValueError(
             f"{icons.red_dot} The '{lakehouse}' lakehouse does not exist within the '{lakehouse_workspace}' workspace. "
-            f"Therefore it cannot be used to support the '{dataset}' semantic model within the '{workspace}' workspace."
+            f"Therefore it cannot be used to support the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
         )
 
     icons.sll_tags.append("UpdateDLConnection")
@@ -60,37 +64,37 @@ def update_direct_lake_model_lakehouse_connection(
     )
 
     with connect_semantic_model(
-        dataset=dataset, readonly=False, workspace=workspace
+        dataset=dataset_id, readonly=False, workspace=workspace_id
     ) 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."
             )
 
         tom.model.Expressions["DatabaseQuery"].Expression = shEx
 
     print(
-        f"{icons.green_dot} The expression in the '{dataset}' semantic model has been updated to point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace."
+        f"{icons.green_dot} The expression in the '{dataset_name}' semantic model has been updated to point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace."
     )
 
 
 def update_direct_lake_model_connection(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     source: Optional[str] = None,
-    source_type: Optional[str] = "Lakehouse",
-    source_workspace: Optional[str] = None,
+    source_type: str = "Lakehouse",
+    source_workspace: Optional[str | UUID] = None,
 ):
     """
     Remaps a Direct Lake semantic model's SQL Endpoint connection to a new lakehouse/warehouse.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name in which the semantic model exists.
+    dataset : str | UUID
+        Name or ID of the semantic model.
+    workspace : str | UUID, default=None
+        The Fabric workspace name or ID in which the semantic model 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.
     source : str, default=None
@@ -98,14 +102,14 @@ def update_direct_lake_model_connection(
         Defaults to None which resolves to the lakehouse attached to the notebook.
     source_type : str, default="Lakehouse"
         The type of source for the Direct Lake semantic model. Valid options: "Lakehouse", "Warehouse".
-    source_workspace : str, default=None
-        The Fabric workspace used by the lakehouse/warehouse.
+    source_workspace : str | UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse/warehouse.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    if workspace is None:
-        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)
 
     source_type = source_type.capitalize()
 
@@ -115,7 +119,7 @@ def update_direct_lake_model_connection(
         )
 
     if source_workspace is None:
-        source_workspace = workspace
+        source_workspace = workspace_name
 
     if source is None:
         source_id = fabric.get_lakehouse_id()
@@ -135,16 +139,16 @@ def update_direct_lake_model_connection(
     )
 
     with connect_semantic_model(
-        dataset=dataset, readonly=False, workspace=workspace
+        dataset=dataset_id, readonly=False, workspace=workspace_id
     ) 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 within the '{workspace_name}' workspace is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
             )
 
         tom.model.Expressions["DatabaseQuery"].Expression = shEx
 
     print(
-        f"{icons.green_dot} The expression in the '{dataset}' semantic model has been updated to point to the '{source}' {source_type.lower()} in the '{source_workspace}' workspace."
+        f"{icons.green_dot} The expression in the '{dataset_name}' semantic model within the '{workspace_name}' workspace has been updated to point to the '{source}' {source_type.lower()} in the '{source_workspace}' workspace."
     )