semantic-link-labs 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

sempy_labs/directlake/_directlake_schema_compare.py

@@ -10,8 +10,10 @@ from IPython.display import display
 from sempy_labs.lakehouse._get_lakehouse_columns import get_lakehouse_columns
 from sempy_labs._list_functions import list_tables
 from typing import Optional
+import sempy_labs._icons as icons
+from sempy._utils._log import log
 
-
+@log
 def direct_lake_schema_compare(
     dataset: str,
     workspace: Optional[str] = None,
@@ -38,14 +40,12 @@ def direct_lake_schema_compare(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    if workspace == None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     if lakehouse_workspace is None:
         lakehouse_workspace = workspace
 
-    if lakehouse == None:
+    if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
 
@@ -55,14 +55,10 @@ def direct_lake_schema_compare(
     dfI_filt = dfI[(dfI["Id"] == sqlEndpointId)]
 
     if len(dfI_filt) == 0:
-        print(
-            f"The SQL Endpoint in the '{dataset}' semantic model in the '{workspace} workspace does not point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace as specified."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} The SQL Endpoint in the '{dataset}' semantic model in the '{workspace} workspace does not point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace as specified.")
 
     if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
-        print(f"The '{dataset}' semantic model is not in Direct Lake mode.")
-        return
+        raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode.")
 
     dfT = list_tables(dataset, workspace)
     dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
@@ -92,19 +88,19 @@ def direct_lake_schema_compare(
 
     if len(missingtbls) == 0:
         print(
-            f"All tables exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
+            f"{icons.green_dot} All tables exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
     else:
         print(
-            f"The following tables exist in the '{dataset}' semantic model within the '{workspace}' workspace but do not exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
+            f"{icons.yellow_dot} The following tables exist in the '{dataset}' semantic model within the '{workspace}' workspace but do not exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingtbls)
     if len(missingcols) == 0:
         print(
-            f"All columns exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
+            f"{icons.green_dot} All columns exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
     else:
         print(
-            f"The following columns exist in the '{dataset}' semantic model within the '{workspace}' workspace but do not exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
+            f"{icons.yellow_dot} The following columns exist in the '{dataset}' semantic model within the '{workspace}' workspace but do not exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingcols)

sempy_labs/directlake/_directlake_schema_sync.py

@@ -2,6 +2,7 @@ import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs.lakehouse._get_lakehouse_columns import get_lakehouse_columns
+from sempy_labs.tom import connect_semantic_model
 from sempy_labs._helper_functions import (
     format_dax_object_name,
     resolve_lakehouse_name,
@@ -9,7 +10,7 @@ from sempy_labs._helper_functions import (
 )
 from typing import Optional
 from sempy._utils._log import log
-
+import sempy_labs._icons as icons
 
 @log
 def direct_lake_schema_sync(
@@ -45,14 +46,12 @@ def direct_lake_schema_sync(
     import Microsoft.AnalysisServices.Tabular as TOM
     import System
 
-    if workspace == None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     if lakehouse_workspace is None:
         lakehouse_workspace = workspace
 
-    if lakehouse == None:
+    if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
 
@@ -62,10 +61,7 @@ def direct_lake_schema_sync(
     dfI_filt = dfI[(dfI["Id"] == sqlEndpointId)]
 
     if len(dfI_filt) == 0:
-        print(
-            f"The SQL Endpoint in the '{dataset}' semantic model in the '{workspace} workspace does not point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace as specified."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} The SQL Endpoint in the '{dataset}' semantic model in the '{workspace} workspace does not point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace as specified.")
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     dfP_filt = dfP[dfP["Source Type"] == "Entity"]
@@ -93,36 +89,35 @@ def direct_lake_schema_sync(
         "double": "Double",
     }
 
-    tom_server = fabric.create_tom_server(readonly=False, workspace=workspace)
-    m = tom_server.Databases.GetByName(dataset).Model
-    for i, r in lc_filt.iterrows():
-        lakeTName = r["Table Name"]
-        lakeCName = r["Column Name"]
-        fullColName = r["Full Column Name"]
-        dType = r["Data Type"]
-
-        if fullColName not in dfC_filt["Column Object"].values:
-            dfL = dfP_filt[dfP_filt["Query"] == lakeTName]
-            tName = dfL["Table Name"].iloc[0]
-            if add_to_model:
-                col = TOM.DataColumn()
-                col.Name = lakeCName
-                col.SourceColumn = lakeCName
-                dt = mapping.get(dType)
-                try:
-                    col.DataType = System.Enum.Parse(TOM.DataType, dt)
-                except:
+    with connect_semantic_model(
+                dataset=dataset, readonly=False, workspace=workspace
+            ) as tom:
+
+        for i, r in lc_filt.iterrows():
+            lakeTName = r["Table Name"]
+            lakeCName = r["Column Name"]
+            fullColName = r["Full Column Name"]
+            dType = r["Data Type"]
+
+            if fullColName not in dfC_filt["Column Object"].values:
+                dfL = dfP_filt[dfP_filt["Query"] == lakeTName]
+                tName = dfL["Table Name"].iloc[0]
+                if add_to_model:
+                    col = TOM.DataColumn()
+                    col.Name = lakeCName
+                    col.SourceColumn = lakeCName
+                    dt = mapping.get(dType)
+                    try:
+                        col.DataType = System.Enum.Parse(TOM.DataType, dt)
+                    except Exception as e:
+                        raise ValueError(f"{icons.red_dot} Failed to map '{dType}' data type to the semantic model data types.") from e
+
+                    tom.model.Tables[tName].Columns.Add(col)
+                    print(
+                        f"{icons.green_dot} The '{lakeCName}' column has been added to the '{tName}' table as a '{dt}' data type within the '{dataset}' semantic model within the '{workspace}' workspace."
+                    )
+                else:
                     print(
-                        f"ERROR: '{dType}' data type is not mapped properly to the semantic model data types."
+                        f"{icons.yellow_dot} The {fullColName} column exists in the lakehouse but not in the '{tName}' table in the '{dataset}' semantic model within the '{workspace}' workspace."
                     )
-                    return
-
-                m.Tables[tName].Columns.Add(col)
-                print(
-                    f"The '{lakeCName}' column has been added to the '{tName}' table as a '{dt}' data type within the '{dataset}' semantic model within the '{workspace}' workspace."
-                )
-            else:
-                print(
-                    f"The {fullColName} column exists in the lakehouse but not in the '{tName}' table in the '{dataset}' semantic model within the '{workspace}' workspace."
-                )
-        m.SaveChanges()
+            

sempy_labs/directlake/_fallback.py

@@ -2,7 +2,7 @@ import sempy
 import sempy.fabric as fabric
 import numpy as np
 from typing import List, Optional, Union
-
+import sempy_labs._icons as icons
 
 def check_fallback_reason(dataset: str, workspace: Optional[str] = None):
     """
@@ -23,17 +23,13 @@ def check_fallback_reason(dataset: str, workspace: Optional[str] = None):
         The tables in the semantic model and their fallback reason.
     """
 
-    if workspace == None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
 
     if len(dfP_filt) == 0:
-        print(
-            f"The '{dataset}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
-        )
+        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.")
     else:
         df = fabric.evaluate_dax(
             dataset=dataset,

sempy_labs/directlake/_get_directlake_lakehouse.py

@@ -7,8 +7,7 @@ from sempy_labs._helper_functions import (
 )
 from typing import Optional, Tuple
 from uuid import UUID
-from sempy_labs._helper_functions import resolve_workspace_name_and_id
-
+import sempy_labs._icons as icons
 
 def get_direct_lake_lakehouse(
     dataset: str,
@@ -46,7 +45,7 @@ def get_direct_lake_lakehouse(
     if lakehouse_workspace is None:
         lakehouse_workspace = workspace
 
-    if lakehouse == None:
+    if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
 
@@ -55,7 +54,7 @@ def get_direct_lake_lakehouse(
 
     if len(dfP_filt) == 0:
         raise ValueError(
-            f"ERROR: The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode."
+            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)

sempy_labs/directlake/_get_shared_expression.py

@@ -1,12 +1,9 @@
 import sempy
 import sempy.fabric as fabric
-from sempy_labs._helper_functions import (
-    resolve_lakehouse_name,
-    resolve_workspace_name_and_id,
-)
+from sempy_labs._helper_functions import resolve_lakehouse_name
 from sempy_labs._list_functions import list_lakehouses
 from typing import Optional
-
+import sempy_labs._icons as icons
 
 def get_shared_expression(
     lakehouse: Optional[str] = None, workspace: Optional[str] = None
@@ -30,8 +27,8 @@ def get_shared_expression(
         Shows the expression which can be used to connect a Direct Lake semantic model to its SQL Endpoint.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-    if lakehouse == None:
+    workspace = fabric.resolve_workspace_name(workspace)
+    if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(lakehouse_id)
 
@@ -43,10 +40,7 @@ def get_shared_expression(
     provStatus = lakeDetail["SQL Endpoint Provisioning Status"].iloc[0]
 
     if provStatus == "InProgress":
-        print(
-            f"The SQL Endpoint for the '{lakehouse}' lakehouse within the '{workspace}' workspace has not yet been provisioned. Please wait until it has been provisioned."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} The SQL Endpoint for the '{lakehouse}' lakehouse within the '{workspace}' workspace has not yet been provisioned. Please wait until it has been provisioned.")
 
     sh = (
         'let\n\tdatabase = Sql.Database("'

sempy_labs/directlake/_guardrails.py

@@ -4,9 +4,9 @@ import pandas as pd
 from typing import List, Optional, Union
 
 
-def get_direct_lake_guardrails():
+def get_direct_lake_guardrails() -> pd.DataFrame:
     """
-    Shows the guardrails for when Direct Lake semantic models will fallback to Direct Query based on Microsoft's online documentation.
+    Shows the guardrails for when Direct Lake semantic models will fallback to Direct Query based on Microsoft's `online documentation <https://learn.microsoft.com/power-bi/enterprise/directlake-overview>`_.
 
     Parameters
     ----------
@@ -44,9 +44,7 @@ def get_sku_size(workspace: Optional[str] = None):
         The SKU size for a workspace.
     """
 
-    if workspace == None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     dfC = fabric.list_capacities()
     dfW = fabric.list_workspaces().sort_values(by="Name", ascending=True)
@@ -62,10 +60,10 @@ def get_sku_size(workspace: Optional[str] = None):
     return sku_value
 
 
-def get_directlake_guardrails_for_sku(sku_size: str):
+def get_directlake_guardrails_for_sku(sku_size: str) -> pd.DataFrame:
     """
     Shows the guardrails for Direct Lake based on the SKU used by your workspace's capacity.
-    *Use the result of the 'get_sku_size' function as an input for this function's skuSize parameter.*
+    * Use the result of the 'get_sku_size' function as an input for this function's sku_size parameter.*
 
     Parameters
     ----------

sempy_labs/directlake/_list_directlake_model_calc_tables.py

@@ -2,14 +2,15 @@ import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._list_functions import list_tables, list_annotations
+from sempy_labs.tom import connect_semantic_model
 from typing import Optional
 from sempy._utils._log import log
-
+import sempy_labs._icons as icons
 
 @log
-def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] = None):
+def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] = None) -> pd.DataFrame:
     """
-    Shows the calculated tables and their respective DAX expression for a Direct Lake model (which has been migrated from import/DirectQuery.
+    Shows the calculated tables and their respective DAX expression for a Direct Lake model (which has been migrated from import/DirectQuery).
 
     Parameters
     ----------
@@ -26,29 +27,30 @@ def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] =
         A pandas dataframe showing the calculated tables which were migrated to Direct Lake and whose DAX expressions are stored as model annotations.
     """
 
-    if workspace == None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     df = pd.DataFrame(columns=["Table Name", "Source Expression"])
 
-    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
-    dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
-
-    if len(dfP_filt) == 0:
-        print(f"The '{dataset}' semantic model is not in Direct Lake mode.")
-    else:
-        dfA = list_annotations(dataset, workspace)
-        dfT = list_tables(dataset, workspace)
-        dfA_filt = dfA[
-            (dfA["Object Type"] == "Model") & (dfA["Annotation Name"].isin(dfT["Name"]))
-        ]
-
-        for i, r in dfA_filt.iterrows():
-            tName = r["Annotation Name"]
-            se = r["Annotation Value"]
-
-            new_data = {"Table Name": tName, "Source Expression": se}
-            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-        return df
+    with connect_semantic_model(
+                dataset=dataset, readonly=True, workspace=workspace
+            ) as tom:
+        
+        is_direct_lake = tom.is_direct_lake()
+
+        if not is_direct_lake:
+            raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode.")
+        else:
+            dfA = list_annotations(dataset, workspace)
+            dfT = list_tables(dataset, workspace)
+            dfA_filt = dfA[
+                (dfA["Object Type"] == "Model") & (dfA["Annotation Name"].isin(dfT["Name"]))
+            ]
+
+            for i, r in dfA_filt.iterrows():
+                tName = r["Annotation Name"]
+                se = r["Annotation Value"]
+
+                new_data = {"Table Name": tName, "Source Expression": se}
+                df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+            return df

sempy_labs/directlake/_show_unsupported_directlake_objects.py

@@ -4,8 +4,9 @@ import pandas as pd
 from sempy_labs._list_functions import list_tables
 from sempy_labs._helper_functions import format_dax_object_name
 from typing import Optional, Tuple
+from sempy._utils._log import log
 
-
+@log
 def show_unsupported_direct_lake_objects(
     dataset: str, workspace: Optional[str] = None
 ) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
@@ -29,9 +30,7 @@ def show_unsupported_direct_lake_objects(
 
     pd.options.mode.chained_assignment = None
 
-    if workspace == None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     dfT = list_tables(dataset, workspace)
     dfC = fabric.list_columns(dataset=dataset, workspace=workspace)

sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py

@@ -5,8 +5,9 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     resolve_workspace_name_and_id,
 )
-from sempy_labs._tom import connect_semantic_model
-from typing import List, Optional, Union
+from sempy_labs.tom import connect_semantic_model
+from typing import Optional
+import sempy_labs._icons as icons
 
 
 def update_direct_lake_model_lakehouse_connection(
@@ -39,12 +40,12 @@ def update_direct_lake_model_lakehouse_connection(
 
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    workspace = fabric.resolve_workspace_name(workspace)
 
-    if lakehouse_workspace == None:
+    if lakehouse_workspace is None:
         lakehouse_workspace = workspace
 
-    if lakehouse == None:
+    if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
 
@@ -53,17 +54,13 @@ def update_direct_lake_model_lakehouse_connection(
     dfI_filt = dfI[(dfI["Display Name"] == lakehouse)]
 
     if len(dfI_filt) == 0:
-        print(
-            f"The '{lakehouse}' lakehouse does not exist within the '{lakehouse_workspace}' workspace. Therefore it cannot be used to support the '{dataset}' semantic model within the '{workspace}' workspace."
-        )
+        raise ValueError(f"{icons.red_dot} The '{lakehouse}' lakehouse does not exist within the '{lakehouse_workspace}' workspace. Therefore it cannot be used to support the '{dataset}' semantic model within the '{workspace}' workspace.")
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
 
     if len(dfP_filt) == 0:
-        print(
-            f"The '{dataset}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
-        )
+        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.")
     else:
         with connect_semantic_model(
             dataset=dataset, readonly=False, workspace=workspace
@@ -73,9 +70,7 @@ def update_direct_lake_model_lakehouse_connection(
             try:
                 tom.model.Expressions["DatabaseQuery"].Expression = shEx
                 print(
-                    f"The expression in the '{dataset}' semantic model has been updated to point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace."
-                )
-            except:
-                print(
-                    f"ERROR: The expression in the '{dataset}' semantic model was not updated."
+                    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."
                 )
+            except Exception as e:
+                raise ValueError(f"{icons.red_dot} The expression in the '{dataset}' semantic model was not updated.") from e

sempy_labs/directlake/_update_directlake_partition_entity.py

@@ -1,13 +1,17 @@
+import sempy
 import sempy.fabric as fabric
-from sempy_labs._tom import connect_semantic_model
+from sempy_labs.tom import connect_semantic_model
+from sempy_labs._helper_functions import resolve_lakehouse_name
 from typing import List, Optional, Union
-
+import sempy_labs._icons as icons
 
 def update_direct_lake_partition_entity(
     dataset: str,
     table_name: Union[str, List[str]],
     entity_name: Union[str, List[str]],
     workspace: Optional[str] = None,
+    lakehouse: Optional[str] = None,
+    lakehouse_workspace: Optional[str] = None
 ):
     """
     Remaps a table (or tables) in a Direct Lake semantic model to a table in a lakehouse.
@@ -24,10 +28,24 @@ def update_direct_lake_partition_entity(
         The Fabric workspace name 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.
+        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)
 
+    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)
+
     # Support both str & list types
     if isinstance(table_name, str):
         table_name = [table_name]
@@ -35,20 +53,14 @@ def update_direct_lake_partition_entity(
         entity_name = [entity_name]
 
     if len(table_name) != len(entity_name):
-        print(
-            f"ERROR: The 'table_name' and 'entity_name' arrays must be of equal length."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} The 'table_name' and 'entity_name' arrays must be of equal length.")
 
     with connect_semantic_model(
         dataset=dataset, readonly=False, workspace=workspace
     ) as tom:
 
         if not tom.is_direct_lake():
-            print(
-                f"The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode."
-            )
-            return
+            raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode.")
 
         for tName in table_name:
             i = table_name.index(tName)
@@ -56,9 +68,7 @@ def update_direct_lake_partition_entity(
             try:
                 tom.model.Tables[tName].Partitions[0].EntityName = eName
                 print(
-                    f"The '{tName}' table in the '{dataset}' semantic model has been updated to point to the '{eName}' table in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
-                )
-            except:
-                print(
-                    f"ERROR: The '{tName}' table in the '{dataset}' semantic model has not been updated."
+                    f"{icons.green_dot} The '{tName}' table in the '{dataset}' semantic model has been updated to point to the '{eName}' table in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
                 )
+            except Exception as e:
+                raise ValueError(f"{icons.red_dot} The '{tName}' table in the '{dataset}' semantic model has not been updated.") from e

sempy_labs/directlake/_warm_cache.py

@@ -45,10 +45,7 @@ def warm_direct_lake_cache_perspective(
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
-        print(
-            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."
-        )
-        return
+        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.")
 
     dfPersp = fabric.list_perspectives(dataset=dataset, workspace=workspace)
     dfPersp["DAX Object Name"] = format_dax_object_name(
@@ -57,10 +54,8 @@ def warm_direct_lake_cache_perspective(
     dfPersp_filt = dfPersp[dfPersp["Perspective Name"] == perspective]
 
     if len(dfPersp_filt) == 0:
-        print(
-            f"{icons.red_dot} The '{perspective} perspective does not exist or contains no objects within the '{dataset}' semantic model in the '{workspace}' workspace."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} The '{perspective} perspective does not exist or contains no objects within the '{dataset}' semantic model in the '{workspace}' workspace.")
+
     dfPersp_c = dfPersp_filt[dfPersp_filt["Object Type"] == "Column"]
 
     column_values = dfPersp_c["DAX Object Name"].tolist()
@@ -131,7 +126,7 @@ def warm_direct_lake_cache_perspective(
         bar.set_description(f"Warming the '{tableName}' table...")
         css = ",".join(map(str, filtered_list))
         dax = """EVALUATE TOPN(1,SUMMARIZECOLUMNS(""" + css + "))" ""
-        x = fabric.evaluate_dax(dataset=dataset, dax_string=dax, workspace=workspace)
+        fabric.evaluate_dax(dataset=dataset, dax_string=dax, workspace=workspace)
 
     print(f"{icons.green_dot} The following columns have been put into memory:")
 
@@ -166,12 +161,13 @@ 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)
+
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
-        print(
-            f"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."
+        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."
         )
-        return
 
     # Identify columns which are currently in memory (Is Resident = True)
     dfC = fabric.list_columns(dataset=dataset, workspace=workspace, extended=True)
@@ -181,10 +177,9 @@ def warm_direct_lake_cache_isresident(
     dfC_filtered = dfC[dfC["Is Resident"]]
 
     if len(dfC_filtered) == 0:
-        print(
+        raise ValueError(
             f"{icons.yellow_dot} At present, no columns are in memory in the '{dataset}' semantic model in the '{workspace}' workspace."
         )
-        return
 
     # Refresh/frame dataset
     refresh_semantic_model(dataset=dataset, refresh_type="full", workspace=workspace)
@@ -199,7 +194,7 @@ def warm_direct_lake_cache_isresident(
         bar.set_description(f"Warming the '{tableName}' table...")
         css = ",".join(map(str, column_values))
         dax = """EVALUATE TOPN(1,SUMMARIZECOLUMNS(""" + css + "))" ""
-        x = fabric.evaluate_dax(dataset=dataset, dax_string=dax, workspace=workspace)
+        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."

sempy_labs/lakehouse/__init__.py

@@ -6,7 +6,6 @@ from sempy_labs.lakehouse._lakehouse import (
 )
 
 from sempy_labs.lakehouse._shortcuts import (
-    list_shortcuts,
     # create_shortcut,
     create_shortcut_onelake,
     delete_shortcut,
@@ -17,7 +16,6 @@ __all__ = [
     "get_lakehouse_tables",
     "lakehouse_attached",
     "optimize_lakehouse_tables",
-    "list_shortcuts",
     # create_shortcut,
     "create_shortcut_onelake",
     "delete_shortcut",