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

sempy_labs/directlake/_get_directlake_lakehouse.py

@@ -3,65 +3,61 @@ 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
+import sempy_labs._icons as icons
 
 
 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)
-
-    if lakehouse_workspace is None:
-        lakehouse_workspace = workspace
-
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
-
-    # dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
-    # dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
-
-    # if len(dfP_filt) == 0:
-    #    raise ValueError(
-    #        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)
-
-    dfI = fabric.list_items(workspace=lakehouse_workspace, type="SQLEndpoint")
-    dfI_filt = dfI[dfI["Id"] == sqlEndpointId]
-    lakehouseName = dfI_filt["Display Name"].iloc[0]
-
-    lakehouseId = resolve_lakehouse_id(lakehouseName, lakehouse_workspace)
-
-    return lakehouseName, lakehouseId
+    from sempy_labs.directlake._dl_helper import get_direct_lake_source
+
+    artifact_type, artifact_name, artifact_id, workspace_id = get_direct_lake_source(
+        dataset=dataset, workspace=workspace
+    )
+
+    if artifact_type in ["Lakehouse", "Warehouse"]:
+        return artifact_name, artifact_id
+    else:
+        dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+        dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
+        if dfP_filt.empty:
+            raise ValueError(
+                f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode."
+            )
+        lakehouse_id = resolve_lakehouse_id(
+            lakehouse=lakehouse, workspace=lakehouse_workspace
+        )
+        return lakehouse, lakehouse_id

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."
     )

sempy_labs/directlake/_update_directlake_partition_entity.py

@@ -3,36 +3,41 @@ import sempy.fabric as fabric
 from sempy_labs.tom import connect_semantic_model
 from sempy_labs._refresh_semantic_model import refresh_semantic_model
 from sempy_labs.directlake._dl_helper import get_direct_lake_source
-from sempy_labs._helper_functions import _convert_data_type
+from sempy_labs._helper_functions import (
+    _convert_data_type,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
+)
 from typing import List, Optional, Union
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 def update_direct_lake_partition_entity(
-    dataset: str,
+    dataset: str | UUID,
     table_name: Union[str, List[str]],
     entity_name: Union[str, List[str]],
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Remaps a table (or tables) in a Direct Lake semantic model to a table in a lakehouse.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
     table_name : str, List[str]
         Name of the table(s) in the semantic model.
     entity_name : str, List[str]
         Name of the lakehouse table to be mapped to the semantic model table.
-    workspace : str, default=None
-        The Fabric workspace name in which the semantic model exists.
+    workspace : str | uuid.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.
     """
 
-    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)
 
     # Support both str & list types
     if isinstance(table_name, str):
@@ -48,12 +53,12 @@ def update_direct_lake_partition_entity(
     icons.sll_tags.append("UpdateDLPartition")
 
     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 within the '{workspace}' workspace 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."
             )
 
         for tName in table_name:
@@ -68,42 +73,39 @@ def update_direct_lake_partition_entity(
 
             if part_name is None:
                 raise ValueError(
-                    f"{icons.red_dot} The '{tName}' table in the '{dataset}' semantic model has not been updated."
+                    f"{icons.red_dot} The '{tName}' table in the '{dataset_name}' semantic model has not been updated."
                 )
 
             tom.model.Tables[tName].Partitions[part_name].Source.EntityName = eName
             print(
-                f"{icons.green_dot} The '{tName}' table in the '{dataset}' semantic model has been updated to point to the '{eName}' table."
+                f"{icons.green_dot} The '{tName}' table in the '{dataset_name}' semantic model within the '{workspace_name}' workspace has been updated to point to the '{eName}' table."
             )
 
 
 def add_table_to_direct_lake_semantic_model(
-    dataset: str,
+    dataset: str | UUID,
     table_name: str,
     lakehouse_table_name: str,
     refresh: bool = True,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Adds a table and all of its columns to a Direct Lake semantic model, based on a Fabric lakehouse table.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
     table_name : str, List[str]
         Name of the table in the semantic model.
     lakehouse_table_name : str
         The name of the Fabric lakehouse table.
     refresh : bool, default=True
         Refreshes the table after it is added to the semantic model.
-    workspace : str, default=None
-        The name of the Fabric workspace in which the semantic model resides.
+    workspace : str | uuid.UUID, default=None
+        The name or ID of the Fabric workspace 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.
-
-    Returns
-    -------
     """
 
     sempy.fabric._client._utils._init_analysis_services()
@@ -111,10 +113,11 @@ def add_table_to_direct_lake_semantic_model(
     from sempy_labs.lakehouse._get_lakehouse_columns import get_lakehouse_columns
     from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
 
-    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":
@@ -122,10 +125,15 @@ def add_table_to_direct_lake_semantic_model(
             f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
         )
 
+    if artifact_type is None:
+        raise ValueError(
+            f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
+        )
+
     lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
 
     with connect_semantic_model(
-        dataset=dataset, readonly=False, workspace=workspace
+        dataset=dataset_id, readonly=False, workspace=workspace_id
     ) as tom:
 
         table_count = tom.model.Tables.Count
@@ -148,12 +156,12 @@ def add_table_to_direct_lake_semantic_model(
                 == TOM.PartitionSourceType.Entity
             )
             raise ValueError(
-                f"The '{lakehouse_table_name}' table already exists in the '{dataset}' semantic model within the '{workspace}' workspace as the '{t_name}' table."
+                f"The '{lakehouse_table_name}' table already exists in the '{dataset_name}' semantic model within the '{workspace_name}' workspace as the '{t_name}' table."
             )
 
         if any(t.Name == table_name for t in tom.model.Tables):
             raise ValueError(
-                f"The '{table_name}' table already exists in the '{dataset}' semantic model within the '{workspace}' workspace."
+                f"The '{table_name}' table already exists in the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
             )
 
         dfL = get_lakehouse_tables(
@@ -173,13 +181,13 @@ def add_table_to_direct_lake_semantic_model(
 
         tom.add_table(name=table_name)
         print(
-            f"{icons.green_dot} The '{table_name}' table has been added to the '{dataset}' semantic model within the '{workspace}' workspace."
+            f"{icons.green_dot} The '{table_name}' table has been added to the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
         )
         tom.add_entity_partition(
             table_name=table_name, entity_name=lakehouse_table_name
         )
         print(
-            f"{icons.green_dot} The '{lakehouse_table_name}' partition has been added to the '{table_name}' table in the '{dataset}' semantic model within the '{workspace}' workspace."
+            f"{icons.green_dot} The '{lakehouse_table_name}' partition has been added to the '{table_name}' table in the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
         )
 
         for i, r in dfLC_filt.iterrows():
@@ -193,10 +201,10 @@ def add_table_to_direct_lake_semantic_model(
                 data_type=dt,
             )
             print(
-                f"{icons.green_dot} The '{lakeCName}' column has been added to the '{table_name}' table as a '{dt}' data type in the '{dataset}' semantic model within the '{workspace}' workspace."
+                f"{icons.green_dot} The '{lakeCName}' column has been added to the '{table_name}' table as a '{dt}' data type in the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
             )
 
         if refresh:
             refresh_semantic_model(
-                dataset=dataset, tables=table_name, workspace=workspace
+                dataset=dataset_id, tables=table_name, workspace=workspace_id
             )