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

sempy_labs/_one_lake_integration.py

@@ -1,9 +1,10 @@
+import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from typing import Optional
 from sempy._utils._log import log
 from sempy_labs._helper_functions import resolve_workspace_name_and_id
-
+import sempy_labs._icons as icons
 
 @log
 def export_model_to_onelake(
@@ -31,7 +32,7 @@ def export_model_to_onelake(
 
     (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
-    if destination_workspace == None:
+    if destination_workspace is None:
         destination_workspace = workspace
         destination_workspace_id = workspace_id
     else:
@@ -42,7 +43,7 @@ def export_model_to_onelake(
 
     if len(dfD_filt) == 0:
         print(
-            f"The '{dataset}' semantic model does not exist in the '{workspace}' workspace."
+            f"{icons.red_dot} The '{dataset}' semantic model does not exist in the '{workspace}' workspace."
         )
         return
 
@@ -64,17 +65,11 @@ def export_model_to_onelake(
     try:
         fabric.execute_tmsl(script=tmsl, workspace=workspace)
         print(
-            f"The '{dataset}' semantic model's tables have been exported as delta tables to the '{workspace}' workspace.\n"
-        )
-    except:
-        print(
-            f"ERROR: The '{dataset}' semantic model's tables have not been exported as delta tables to the '{workspace}' workspace."
-        )
-        print(
-            f"Make sure you enable OneLake integration for the '{dataset}' semantic model. Follow the instructions here: https://learn.microsoft.com/power-bi/enterprise/onelake-integration-overview#enable-onelake-integration"
+            f"{icons.green_dot} The '{dataset}' semantic model's tables have been exported as delta tables to the '{workspace}' workspace.\n"
         )
-        return
-
+    except Exception as e:
+        raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model's tables have not been exported as delta tables to the '{workspace}' workspace.\nMake sure you enable OneLake integration for the '{dataset}' semantic model. Follow the instructions here: https://learn.microsoft.com/power-bi/enterprise/onelake-integration-overview#enable-onelake-integration") from e
+        
     # Create shortcuts if destination lakehouse is specified
     if destination_lakehouse is not None:
         # Destination...
@@ -83,14 +78,14 @@ def export_model_to_onelake(
 
         if len(dfI_filt) == 0:
             print(
-                f"The '{destination_lakehouse}' lakehouse does not exist within the '{destination_workspace}' workspace."
+                f"{icons.red_dot} The '{destination_lakehouse}' lakehouse does not exist within the '{destination_workspace}' workspace."
             )
             # Create lakehouse
             destination_lakehouse_id = fabric.create_lakehouse(
                 display_name=destination_lakehouse, workspace=destination_workspace
             )
             print(
-                f"The '{destination_lakehouse}' lakehouse has been created within the '{destination_workspace}' workspace.\n"
+                f"{icons.green_dot} The '{destination_lakehouse}' lakehouse has been created within the '{destination_workspace}' workspace.\n"
             )
         else:
             destination_lakehouse_id = dfI_filt["Id"].iloc[0]
@@ -109,7 +104,7 @@ def export_model_to_onelake(
         dfP_filt = dfP[
             (dfP["Mode"] == "Import")
             & (dfP["Source Type"] != "CalculationGroup")
-            & (dfP["Parent System Managed"] == False)
+            & (dfP["Parent System Managed"] is False)
         ]
         dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
         tmc = pd.DataFrame(dfP.groupby("Table Name")["Mode"].nunique()).reset_index()
@@ -122,7 +117,7 @@ def export_model_to_onelake(
 
         client = fabric.FabricRestClient()
 
-        print("Creating shortcuts...\n")
+        print(f"{icons.in_progress} Creating shortcuts...\n")
         for tableName in tables:
             tablePath = "Tables/" + tableName
             shortcutName = tableName.replace(" ", "")
@@ -145,11 +140,9 @@ def export_model_to_onelake(
                 )
                 if response.status_code == 201:
                     print(
-                        f"\u2022 The shortcut '{shortcutName}' was created in the '{destination_lakehouse}' lakehouse within the '{destination_workspace}' workspace. It is based on the '{tableName}' table in the '{dataset}' semantic model within the '{workspace}' workspace.\n"
+                        f"{icons.bullet} The shortcut '{shortcutName}' was created in the '{destination_lakehouse}' lakehouse within the '{destination_workspace}' workspace. It is based on the '{tableName}' table in the '{dataset}' semantic model within the '{workspace}' workspace.\n"
                     )
                 else:
                     print(response.status_code)
-            except:
-                print(
-                    f"ERROR: Failed to create a shortcut for the '{tableName}' table."
-                )
+            except Exception as e:
+                raise ValueError(f"{icons.red_dot} Failed to create a shortcut for the '{tableName}' table.") from e

sempy_labs/_query_scale_out.py

@@ -2,7 +2,7 @@ import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._helper_functions import resolve_dataset_id
-from typing import List, Optional, Union
+from typing import Optional
 import sempy_labs._icons as icons
 
 

sempy_labs/_refresh_semantic_model.py

@@ -2,7 +2,7 @@ import sempy
 import sempy.fabric as fabric
 import time
 from sempy_labs._helper_functions import resolve_dataset_id
-from typing import List, Optional, Union
+from typing import Any, List, Optional, Union
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 from sempy_labs._helper_functions import resolve_workspace_name_and_id
@@ -41,7 +41,7 @@ def refresh_semantic_model(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -53,7 +53,7 @@ def refresh_semantic_model(
     if isinstance(partitions, str):
         partitions = [partitions]
 
-    objects = []
+    objects: List[Any] = []
 
     if tables is not None:
         objects = objects + [{"table": table} for table in tables]
@@ -161,7 +161,7 @@ def cancel_dataset_refresh(
     rr = fabric.list_refresh_requests(dataset=dataset, workspace=workspace)
     rr_filt = rr[rr["Status"] == "Unknown"]
 
-    if request_id == None:
+    if request_id is None:
         if len(rr_filt) == 0:
             print(
                 f"{icons.red_dot} There are no active Enhanced API refreshes of the '{dataset}' semantic model within the '{workspace}' workspace."

sempy_labs/_translations.py

@@ -35,7 +35,7 @@ def translate_semantic_model(
     from synapse.ml.services import Translate
     from pyspark.sql.functions import col, flatten
     from pyspark.sql import SparkSession
-    from ._tom import connect_semantic_model
+    from .tom import connect_semantic_model
 
     if isinstance(languages, str):
         languages = [languages]
@@ -212,7 +212,7 @@ def translate_semantic_model(
                 print(f"{icons.in_progress} Translating into the '{lang}' language...")
 
                 for t in tom.model.Tables:
-                    if t.IsHidden == False:
+                    if t.IsHidden is False:
                         if clm == "Name":
                             df_filt = df_panda[
                                 (df_panda["Object Type"] == "Table")
@@ -240,7 +240,7 @@ def translate_semantic_model(
                                     value=tr,
                                 )
                         for c in t.Columns:
-                            if c.IsHidden == False:
+                            if c.IsHidden is False:
                                 if clm == "Name":
                                     df_filt = df_panda[
                                         (df_panda["Object Type"] == "Column")
@@ -287,7 +287,7 @@ def translate_semantic_model(
                                             value=tr,
                                         )
                         for h in t.Hierarchies:
-                            if h.IsHidden == False:
+                            if h.IsHidden is False:
                                 if clm == "Name":
                                     df_filt = df_panda[
                                         (df_panda["Object Type"] == "Hierarchy")
@@ -331,7 +331,7 @@ def translate_semantic_model(
                                             value=tr,
                                         )
                     for ms in t.Measures:
-                        if ms.IsHidden == False:
+                        if ms.IsHidden is False:
                             if clm == "Name":
                                 df_filt = df_panda[
                                     (df_panda["Object Type"] == "Measure")

sempy_labs/_vertipaq.py

@@ -14,7 +14,7 @@ from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
 from sempy_labs.lakehouse._lakehouse import lakehouse_attached
 from typing import List, Optional, Union
 from sempy._utils._log import log
-
+import sempy_labs._icons as icons
 
 @log
 def vertipaq_analyzer(
@@ -56,11 +56,11 @@ def vertipaq_analyzer(
         "ignore", message="createDataFrame attempted Arrow optimization*"
     )
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
-    if lakehouse_workspace == None:
+    if lakehouse_workspace is None:
         lakehouse_workspace = workspace
 
     dfT = fabric.list_tables(dataset=dataset, extended=True, workspace=workspace)
@@ -103,7 +103,7 @@ def vertipaq_analyzer(
 
             if len(dfI_filt) == 0:
                 print(
-                    f"The lakehouse (SQL Endpoint) used by the '{dataset}' semantic model does not reside in the '{lakehouse_workspace}' workspace. Please update the lakehouse_workspace parameter."
+                    f"{icons.red_dot} The lakehouse (SQL Endpoint) used by the '{dataset}' semantic model does not reside in the '{lakehouse_workspace}' workspace. Please update the lakehouse_workspace parameter."
                 )
             else:
                 lakehouseName = dfI_filt["Display Name"].iloc[0]
@@ -233,7 +233,7 @@ def vertipaq_analyzer(
 
                 query = f"evaluate\nsummarizecolumns(\n\"1\",calculate(countrows('{fromTable}'),isblank({toObject}))\n)"
 
-                if isActive == False:  # add userelationship
+                if isActive is False:  # add userelationship
                     query = f"evaluate\nsummarizecolumns(\n\"1\",calculate(countrows('{fromTable}'),userelationship({fromObject},{toObject}),isblank({toObject}))\n)"
 
                 result = fabric.evaluate_dax(
@@ -359,7 +359,7 @@ def vertipaq_analyzer(
         "Max To Cardinality",
         "Missing Rows",
     ]
-    if read_stats_from_data == False:
+    if read_stats_from_data is False:
         intList.remove("Missing Rows")
     dfR[intList] = dfR[intList].applymap("{:,}".format)
 
@@ -436,9 +436,9 @@ def vertipaq_analyzer(
     ### Export vertipaq to delta tables in lakehouse
     if export in ["table", "zip"]:
         lakeAttach = lakehouse_attached()
-        if lakeAttach == False:
+        if lakeAttach is False:
             print(
-                f"In order to save the Vertipaq Analyzer results, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
+                f"{icons.red_dot} In order to save the Vertipaq Analyzer results, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
             )
             return
 
@@ -472,7 +472,7 @@ def vertipaq_analyzer(
             "export_Model": ["Model", export_Model],
         }
 
-        print(f"Saving Vertipaq Analyzer to delta tables in the lakehouse...\n")
+        print(f"{icons.in_progress} Saving Vertipaq Analyzer to delta tables in the lakehouse...\n")
         now = datetime.datetime.now()
         for key, (obj, df) in dfMap.items():
             df["Timestamp"] = now
@@ -491,7 +491,7 @@ def vertipaq_analyzer(
             spark_df = spark.createDataFrame(df)
             spark_df.write.mode("append").format("delta").saveAsTable(delta_table_name)
             print(
-                f"\u2022 Vertipaq Analyzer results for '{obj}' have been appended to the '{delta_table_name}' delta table."
+                f"{icons.bullet} Vertipaq Analyzer results for '{obj}' have been appended to the '{delta_table_name}' delta table."
             )
 
     ### Export vertipaq to zip file within the lakehouse
@@ -532,7 +532,7 @@ def vertipaq_analyzer(
             if os.path.exists(filePath):
                 os.remove(filePath)
         print(
-            f"The Vertipaq Analyzer info for the '{dataset}' semantic model in the '{workspace}' workspace has been saved to the 'Vertipaq Analyzer/{zipFileName}' in the default lakehouse attached to this notebook."
+            f"{icons.green_dot} The Vertipaq Analyzer info for the '{dataset}' semantic model in the '{workspace}' workspace has been saved to the 'Vertipaq Analyzer/{zipFileName}' in the default lakehouse attached to this notebook."
         )
 
 

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,14 @@ def direct_lake_schema_compare(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
     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)
 
@@ -56,12 +58,12 @@ def direct_lake_schema_compare(
 
     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."
+            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."
         )
         return
 
     if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
-        print(f"The '{dataset}' semantic model is not in Direct Lake mode.")
+        print(f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode.")
         return
 
     dfT = list_tables(dataset, workspace)
@@ -92,19 +94,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,13 @@ 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)
+    if workspace is None:
+        workspace = fabric.resolve_workspace_name()
 
     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)
 
@@ -63,7 +63,7 @@ def direct_lake_schema_sync(
 
     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."
+            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."
         )
         return
 
@@ -93,36 +93,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,7 +23,7 @@ def check_fallback_reason(dataset: str, workspace: Optional[str] = None):
         The tables in the semantic model and their fallback reason.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -32,7 +32,7 @@ def check_fallback_reason(dataset: str, workspace: Optional[str] = None):
 
     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."
+            f"{icons.yellow_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(

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

@@ -6,7 +6,7 @@ from sempy_labs._helper_functions import (
 )
 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
@@ -31,7 +31,7 @@ def get_shared_expression(
     """
 
     (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-    if lakehouse == None:
+    if lakehouse is None:
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(lakehouse_id)
 
@@ -44,7 +44,7 @@ def get_shared_expression(
 
     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."
+            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."
         )
         return
 

sempy_labs/directlake/_guardrails.py

@@ -6,7 +6,7 @@ from typing import List, Optional, Union
 
 def get_direct_lake_guardrails():
     """
-    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,7 +44,7 @@ def get_sku_size(workspace: Optional[str] = None):
         The SKU size for a workspace.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -65,7 +65,7 @@ def get_sku_size(workspace: Optional[str] = None):
 def get_directlake_guardrails_for_sku(sku_size: str):
     """
     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):
     """
-    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,31 @@ 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)
+    if workspace is None:
+        workspace = fabric.resolve_workspace_name()
 
     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:
+            print(f"{icons.yellow_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