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

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":
@@ -125,7 +128,7 @@ def add_table_to_direct_lake_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 +151,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 +176,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 +196,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
             )

sempy_labs/directlake/_warm_cache.py

@@ -3,34 +3,39 @@ import pandas as pd
 from tqdm.auto import tqdm
 import numpy as np
 import time
-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 sempy_labs._refresh_semantic_model import refresh_semantic_model
 from sempy_labs._model_dependencies import get_measure_dependencies
 from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 @log
 def warm_direct_lake_cache_perspective(
-    dataset: str,
+    dataset: str | UUID,
     perspective: str,
     add_dependencies: bool = False,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ) -> pd.DataFrame:
     """
     Warms the cache of a Direct Lake semantic model by running a simple DAX query against the columns in a perspective.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
     perspective : str
         Name of the perspective which contains objects to be used for warming the cache.
     add_dependencies : bool, default=False
         Includes object dependencies in the cache warming process.
-    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,15 +45,16 @@ def warm_direct_lake_cache_perspective(
         Returns a pandas dataframe showing the columns that have been put into memory.
     """
 
-    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)
 
-    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
-    if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
+    dfP = fabric.list_partitions(dataset=dataset_id, workspace=workspace_id)
+    if not any(r["Mode"] == "DirectLake" for _, r in dfP.iterrows()):
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model in the '{workspace}' workspace is not in Direct Lake mode. This function is specifically for semantic models in Direct Lake mode."
+            f"{icons.red_dot} The '{dataset_name}' semantic model in the '{workspace_name}' workspace is not in Direct Lake mode. This function is specifically for semantic models in Direct Lake mode."
         )
 
-    dfPersp = fabric.list_perspectives(dataset=dataset, workspace=workspace)
+    dfPersp = fabric.list_perspectives(dataset=dataset_id, workspace=workspace_id)
     dfPersp["DAX Object Name"] = format_dax_object_name(
         dfPersp["Table Name"], dfPersp["Object Name"]
     )
@@ -65,7 +71,7 @@ def warm_direct_lake_cache_perspective(
 
     if add_dependencies:
         # Measure dependencies
-        md = get_measure_dependencies(dataset, workspace)
+        md = get_measure_dependencies(dataset_id, workspace_id)
         md["Referenced Full Object"] = format_dax_object_name(
             md["Referenced Table"], md["Referenced Object"]
         )
@@ -78,7 +84,7 @@ def warm_direct_lake_cache_perspective(
 
         # Hierarchy dependencies
         dfPersp_h = dfPersp_filt[(dfPersp_filt["Object Type"] == "Hierarchy")]
-        dfH = fabric.list_hierarchies(dataset=dataset, workspace=workspace)
+        dfH = fabric.list_hierarchies(dataset=dataset_id, workspace=workspace_id)
         dfH["Hierarchy Object"] = format_dax_object_name(
             dfH["Table Name"], dfH["Hierarchy Name"]
         )
@@ -92,7 +98,7 @@ def warm_direct_lake_cache_perspective(
 
         # Relationship dependencies
         unique_table_names = dfPersp_filt["Table Name"].unique()
-        dfR = fabric.list_relationships(dataset=dataset, workspace=workspace)
+        dfR = fabric.list_relationships(dataset=dataset_id, workspace=workspace_id)
         dfR["From Object"] = format_dax_object_name(
             dfR["From Table"], dfR["From Column"]
         )
@@ -120,41 +126,22 @@ def warm_direct_lake_cache_perspective(
     df["Table Name"] = df["Table Name"].str[1:-1]
     df["Column Name"] = df["Column Name"].str[0:-1]
 
-    tbls = list(set(value.split("[")[0] for value in merged_list_unique))
-
-    for tableName in (bar := tqdm(tbls)):
-        filtered_list = [
-            value for value in merged_list_unique if value.startswith(f"{tableName}[")
-        ]
-        bar.set_description(f"Warming the '{tableName}' table...")
-        css = ",".join(map(str, filtered_list))
-        dax = """EVALUATE TOPN(1,SUMMARIZECOLUMNS(""" + css + "))" ""
-        fabric.evaluate_dax(dataset=dataset, dax_string=dax, workspace=workspace)
-
-    print(f"{icons.green_dot} The following columns have been put into memory:")
-
-    new_column_order = ["Table Name", "Column Name", "DAX Object Name"]
-    df = df.reindex(columns=new_column_order)
-    df = df[["Table Name", "Column Name"]].sort_values(
-        by=["Table Name", "Column Name"], ascending=True
-    )
-
-    return df
+    return _put_columns_into_memory(dataset=dataset, workspace=workspace, col_df=df)
 
 
 @log
 def warm_direct_lake_cache_isresident(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> pd.DataFrame:
     """
     Performs a refresh on the semantic model and puts the columns which were in memory prior to the refresh back into memory.
 
     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.
 
@@ -164,46 +151,81 @@ def warm_direct_lake_cache_isresident(
         Returns a pandas dataframe showing the columns that have been put into memory.
     """
 
-    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)
 
-    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
-    if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
+    dfP = fabric.list_partitions(dataset=dataset_id, workspace=workspace_id)
+    if not any(r["Mode"] == "DirectLake" for _, r in dfP.iterrows()):
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model in the '{workspace}' workspace is not in Direct Lake mode. This function is specifically for semantic models in Direct Lake mode."
+            f"{icons.red_dot} The '{dataset_name}' semantic model in the '{workspace_name}' workspace is not in Direct Lake mode. This function is specifically for semantic models in Direct Lake mode."
         )
 
     # Identify columns which are currently in memory (Is Resident = True)
-    dfC = fabric.list_columns(dataset=dataset, workspace=workspace, extended=True)
-    dfC["DAX Object Name"] = format_dax_object_name(
-        dfC["Table Name"], dfC["Column Name"]
-    )
+    dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id, extended=True)
     dfC_filtered = dfC[dfC["Is Resident"] == True]
 
     if len(dfC_filtered) == 0:
         raise ValueError(
-            f"{icons.yellow_dot} At present, no columns are in memory in the '{dataset}' semantic model in the '{workspace}' workspace."
+            f"{icons.yellow_dot} At present, no columns are in memory in the '{dataset_name}' semantic model in the '{workspace_name}' workspace."
         )
 
     # Refresh/frame dataset
-    refresh_semantic_model(dataset=dataset, refresh_type="full", workspace=workspace)
+    refresh_semantic_model(
+        dataset=dataset_id, refresh_type="full", workspace=workspace_id
+    )
     time.sleep(2)
 
-    # Run basic query to get columns into memory; completed one table at a time (so as not to overload the capacity)
-    tbls = dfC_filtered["Table Name"].unique()
+    return _put_columns_into_memory(
+        dataset=dataset, workspace=workspace, col_df=dfC_filtered
+    )
+
+
+def _put_columns_into_memory(dataset, workspace, col_df, return_dataframe: bool = True):
+
+    row_limit = 1000000
+
+    dfT = fabric.list_tables(dataset=dataset, workspace=workspace, extended=True)
+    col_df = col_df.copy()
+
+    col_df["DAX Object"] = format_dax_object_name(
+        col_df["Table Name"], col_df["Column Name"]
+    )
+    tbls = col_df["Table Name"].unique()
+
     for table_name in (bar := tqdm(tbls)):
-        bar.set_description(f"Warming the '{table_name}' table...")
-        css = ", ".join(
-            dfC_filtered[dfC_filtered["Table Name"] == table_name]["DAX Object Name"]
-            .astype(str)
-            .tolist()
+        dfT_filt = dfT[dfT["Name"] == table_name]
+        col_df_filt = col_df[col_df["Table Name"] == table_name]
+        if not dfT_filt.empty:
+            row_count = dfT_filt["Row Count"].iloc[0]
+            bar.set_description(f"Warming the '{table_name}' table...")
+            if row_count < row_limit:
+                columns = col_df_filt["DAX Object"].tolist()
+                css = ", ".join(columns)
+                dax = f"EVALUATE TOPN(1, SELECTCOLUMNS('{table_name}', {css}))"
+                fabric.evaluate_dax(
+                    dataset=dataset, dax_string=dax, workspace=workspace
+                )
+            else:
+                for _, r in col_df_filt.iterrows():
+                    dax_object = r["DAX Object"]
+                    dax = f"""EVALUATE TOPN(1, SELECTCOLUMNS('{table_name}', {dax_object}))"""
+                    fabric.evaluate_dax(
+                        dataset=dataset, dax_string=dax, workspace=workspace
+                    )
+
+    if return_dataframe:
+        print(
+            f"{icons.green_dot} The following columns have been put into memory. Temperature indicates the current column temperature."
         )
-        dax = f"""EVALUATE TOPN(1,SUMMARIZECOLUMNS({css}))"""
-        fabric.evaluate_dax(dataset=dataset, dax_string=dax, workspace=workspace)
 
-    print(
-        f"{icons.green_dot} The following columns have been put into memory. Temperature indicates the column temperature prior to the semantic model refresh."
-    )
+        dfC = fabric.list_columns(dataset=dataset, workspace=workspace, extended=True)
+        dfC["DAX Object"] = format_dax_object_name(
+            dfC["Table Name"], dfC["Column Name"]
+        )
+        dfC_filt = dfC[dfC["DAX Object"].isin(col_df["DAX Object"].values)]
 
-    return dfC_filtered[
-        ["Table Name", "Column Name", "Is Resident", "Temperature"]
-    ].sort_values(by=["Table Name", "Column Name"], ascending=True)
+        return (
+            dfC_filt[["Table Name", "Column Name", "Is Resident", "Temperature"]]
+            .sort_values(by=["Table Name", "Column Name"], ascending=True)
+            .reset_index(drop=True)
+        )

sempy_labs/lakehouse/_get_lakehouse_columns.py

@@ -5,14 +5,16 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     format_dax_object_name,
     resolve_lakehouse_id,
+    resolve_workspace_name_and_id,
 )
 from typing import Optional
 from sempy._utils._log import log
+from uuid import UUID
 
 
 @log
 def get_lakehouse_columns(
-    lakehouse: Optional[str] = None, workspace: Optional[str] = None
+    lakehouse: Optional[str] = None, workspace: Optional[str | UUID] = None
 ) -> pd.DataFrame:
     """
     Shows the tables and columns of a lakehouse and their respective properties.
@@ -22,8 +24,8 @@ def get_lakehouse_columns(
     lakehouse : str, default=None
         The Fabric lakehouse.
         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.
 
@@ -46,18 +48,18 @@ def get_lakehouse_columns(
         ]
     )
 
-    workspace = fabric.resolve_workspace_name(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)
 
     spark = SparkSession.builder.getOrCreate()
 
     tables = get_lakehouse_tables(
-        lakehouse=lakehouse, workspace=workspace, extended=False, count_rows=False
+        lakehouse=lakehouse, workspace=workspace_id, extended=False, count_rows=False
     )
     tables_filt = tables[tables["Format"] == "delta"]
 
@@ -70,7 +72,7 @@ def get_lakehouse_columns(
         for cName, data_type in sparkdf.dtypes:
             tc = format_dax_object_name(tName, cName)
             new_data = {
-                "Workspace Name": workspace,
+                "Workspace Name": workspace_name,
                 "Lakehouse Name": lakehouse,
                 "Table Name": tName,
                 "Column Name": cName,

sempy_labs/lakehouse/_get_lakehouse_tables.py

@@ -18,12 +18,13 @@ from typing import Optional
 import sempy_labs._icons as icons
 from sempy._utils._log import log
 from sempy.fabric.exceptions import FabricHTTPException
+from uuid import UUID
 
 
 @log
 def get_lakehouse_tables(
     lakehouse: Optional[str] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     extended: bool = False,
     count_rows: bool = False,
     export: bool = False,
@@ -38,8 +39,8 @@ def get_lakehouse_tables(
     lakehouse : str, default=None
         The Fabric lakehouse.
         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.
     extended : bool, default=False
@@ -66,13 +67,13 @@ def get_lakehouse_tables(
         ]
     )
 
-    (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)
 
     if count_rows:  # Setting countrows defaults to extended=True
         extended = True
@@ -104,7 +105,7 @@ def get_lakehouse_tables(
     for r in responses:
         for i in r.get("data", []):
             new_data = {
-                "Workspace Name": workspace,
+                "Workspace Name": workspace_name,
                 "Lakehouse Name": lakehouse,
                 "Table Name": i.get("name"),
                 "Format": i.get("format"),
@@ -117,7 +118,7 @@ def get_lakehouse_tables(
         df = pd.concat(dfs, ignore_index=True)
 
     if extended:
-        sku_value = get_sku_size(workspace)
+        sku_value = get_sku_size(workspace_id)
         guardrail = get_directlake_guardrails_for_sku(sku_value)
         spark = SparkSession.builder.getOrCreate()
         df["Files"] = None
@@ -182,7 +183,7 @@ def get_lakehouse_tables(
 
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(
-            lakehouse_id=lakehouse_id, workspace=workspace
+            lakehouse_id=lakehouse_id, workspace=workspace_id
         )
         lakeTName = "lakehouse_table_details"
         lakeT_filt = df[df["Table Name"] == lakeTName]

sempy_labs/lakehouse/_lakehouse.py

@@ -1,8 +1,12 @@
 import sempy.fabric as fabric
 from tqdm.auto import tqdm
-from sempy_labs._helper_functions import resolve_lakehouse_name
+from sempy_labs._helper_functions import (
+    resolve_lakehouse_name,
+    resolve_workspace_name_and_id,
+)
 from typing import List, Optional, Union
 from sempy._utils._log import log
+from uuid import UUID
 
 
 def lakehouse_attached() -> bool:
@@ -29,7 +33,7 @@ def lakehouse_attached() -> bool:
 def optimize_lakehouse_tables(
     tables: Optional[Union[str, List[str]]] = None,
     lakehouse: Optional[str] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Runs the `OPTIMIZE <https://docs.delta.io/latest/optimizations-oss.html>`_ function over the specified lakehouse tables.
@@ -42,8 +46,8 @@ def optimize_lakehouse_tables(
     lakehouse : str, default=None
         The Fabric lakehouse.
         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.
     """
@@ -52,13 +56,13 @@ def optimize_lakehouse_tables(
     from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
     from delta import DeltaTable
 
-    workspace = fabric.resolve_workspace_name(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)
 
-    lakeTables = get_lakehouse_tables(lakehouse=lakehouse, workspace=workspace)
+    lakeTables = get_lakehouse_tables(lakehouse=lakehouse, workspace=workspace_id)
     lakeTablesDelta = lakeTables[lakeTables["Format"] == "delta"]
 
     if isinstance(tables, str):
@@ -83,7 +87,7 @@ def optimize_lakehouse_tables(
 def vacuum_lakehouse_tables(
     tables: Optional[Union[str, List[str]]] = None,
     lakehouse: Optional[str] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     retain_n_hours: Optional[int] = None,
 ):
     """
@@ -96,8 +100,8 @@ def vacuum_lakehouse_tables(
     lakehouse : str, default=None
         The Fabric lakehouse.
         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.
     retain_n_hours : int, default=None
@@ -111,13 +115,13 @@ def vacuum_lakehouse_tables(
     from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
     from delta import DeltaTable
 
-    workspace = fabric.resolve_workspace_name(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)
 
-    lakeTables = get_lakehouse_tables(lakehouse=lakehouse, workspace=workspace)
+    lakeTables = get_lakehouse_tables(lakehouse=lakehouse, workspace=workspace_id)
     lakeTablesDelta = lakeTables[lakeTables["Format"] == "delta"]
 
     if isinstance(tables, str):