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

sempy_labs/_model_auto_build.py

@@ -41,9 +41,7 @@ def model_auto_build(
 
     """
 
-    if workspace is 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
@@ -60,7 +58,7 @@ def model_auto_build(
 
     create_blank_semantic_model(dataset=dataset, workspace=workspace)
 
-    with connect_semantic_model(dataset=dataset, workspace=workspace) as tom:
+    with connect_semantic_model(dataset=dataset, workspace=workspace, readonly=False) as tom:
 
         # DL Only
         expr = get_shared_expression(lakehouse=lakehouse, workspace=lakehouse_workspace)

sempy_labs/_model_bpa.py

@@ -11,7 +11,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
 
 def model_bpa_rules():
     """
@@ -70,8 +70,8 @@ def model_bpa_rules():
                 "Table",
                 "Warning",
                 "Avoid using many-to-many relationships on tables used for dynamic row level security",
-                lambda df: (df["Used in M2M Relationship"] is True)
-                & (df["Used in Dynamic RLS"] is True),
+                lambda df: (df["Used in M2M Relationship"] == True)
+                & (df["Used in Dynamic RLS"] == True),
                 "Using many-to-many relationships on tables which use dynamic row level security can cause serious query performance degradation. This pattern's performance problems compound when snowflaking multiple many-to-many relationships against a table which contains row level security. Instead, use one of the patterns shown in the article below where a single dimension table relates many-to-one to a security table.",
                 "https://www.elegantbi.com/post/dynamicrlspatterns",
             ),
@@ -88,12 +88,12 @@ def model_bpa_rules():
                 "Column",
                 "Warning",
                 "Set IsAvailableInMdx to false on non-attribute columns",
-                lambda df: (df["Is Direct Lake"] is False)
-                & (df["Is Available in MDX"] is True)
-                & ((df["Hidden"] is True) | (df["Parent Is Hidden"] is True))
-                & (df["Used in Sort By"] is False)
-                & (df["Used in Hierarchy"] is False)
-                & (df["Sort By Column"] is None),
+                lambda df: (df["Is Direct Lake"] == False)
+                & (df["Is Available in MDX"] == True)
+                & ((df["Hidden"] == True) | (df["Parent Is Hidden"] == True))
+                & (df["Used in Sort By"] == False)
+                & (df["Used in Hierarchy"] == False)
+                & (df["Sort By Column"] == None),
                 "To speed up processing time and conserve memory after processing, attribute hierarchies should not be built for columns that are never used for slicing by MDX clients. In other words, all hidden columns that are not used as a Sort By Column or referenced in user hierarchies should have their IsAvailableInMdx property set to false. The IsAvailableInMdx property is not relevant for Direct Lake models.",
                 "https://blog.crossjoin.co.uk/2018/07/02/isavailableinmdx-ssas-tabular",
             ),
@@ -219,7 +219,7 @@ def model_bpa_rules():
                 "Table",
                 "Warning",
                 "Large tables should be partitioned",
-                lambda df: (df["Is Direct Lake"] is False)
+                lambda df: (df["Is Direct Lake"] == False)
                 & (df["Partition Count"] == 1)
                 & (df["Row Count"] > 25000000),
                 "Large tables should be partitioned in order to optimize processing. This is not relevant for semantic models in Direct Lake mode as they can only have one partition per table.",
@@ -306,11 +306,11 @@ def model_bpa_rules():
                 "Column",
                 "Warning",
                 "Set IsAvailableInMdx to true on necessary columns",
-                lambda df: (df["Is Direct Lake"] is False)
-                & (df["Is Available in MDX"] is False)
+                lambda df: (df["Is Direct Lake"] == False)
+                & (df["Is Available in MDX"] == False)
                 & (
-                    (df["Used in Sort By"] is True)
-                    | (df["Used in Hierarchy"] is True)
+                    (df["Used in Sort By"] == True)
+                    | (df["Used in Hierarchy"] == True)
                     | (df["Sort By Column"] != None)
                 ),
                 "In order to avoid errors, ensure that attribute hierarchies are enabled if a column is used for sorting another column, used in a hierarchy, used in variations, or is sorted by another column. The IsAvailableInMdx property is not relevant for Direct Lake models.",
@@ -320,8 +320,8 @@ def model_bpa_rules():
                 "Table",
                 "Error",
                 "Avoid the USERELATIONSHIP function and RLS against the same table",
-                lambda df: (df["USERELATIONSHIP Used"] is True)
-                & (df["Used in RLS"] is True),
+                lambda df: (df["USERELATIONSHIP Used"] == True)
+                & (df["Used in RLS"] == True),
                 "The USERELATIONSHIP function may not be used against a table which also leverages row-level security (RLS). This will generate an error when using the particular measure in a visual. This rule will highlight the table which is used in a measure's USERELATIONSHIP function as well as RLS.",
                 "https://blog.crossjoin.co.uk/2013/05/10/userelationship-and-tabular-row-security",
             ),
@@ -494,7 +494,7 @@ def model_bpa_rules():
                 "Table",
                 "Warning",
                 "Ensure tables have relationships",
-                lambda df: (df["Used in Relationship"] is False)
+                lambda df: (df["Used in Relationship"] == False)
                 & (df["Type"] != "Calculation Group"),
                 "This rule highlights tables which are not connected to any other table in the model with a relationship.",
             ),
@@ -511,7 +511,7 @@ def model_bpa_rules():
                 "Column",
                 "Info",
                 "Visible objects with no description",
-                lambda df: (df["Hidden"] is False) & (df["Description"].str.len() == 0),
+                lambda df: (df["Hidden"] == False) & (df["Description"].str.len() == 0),
                 "Calculation groups have no function unless they have calculation items.",
             ),
             (
@@ -595,7 +595,7 @@ def model_bpa_rules():
                 "Column",
                 "Info",
                 "Hide foreign keys",
-                lambda df: (df["Foreign Key"]) & (df["Hidden"] is False),
+                lambda df: (df["Foreign Key"]) & (df["Hidden"] == False),
                 "Foreign keys should always be hidden.",
             ),
             (
@@ -603,7 +603,7 @@ def model_bpa_rules():
                 "Column",
                 "Info",
                 "Mark primary keys",
-                lambda df: (df["Primary Key"]) & (df["Key"] is False),
+                lambda df: (df["Primary Key"]) & (df["Key"] == False),
                 "Set the 'Key' property to 'True' for primary key columns within the column properties.",
             ),
             (
@@ -744,9 +744,7 @@ def run_model_bpa(
         message="This pattern is interpreted as a regular expression, and has match groups.",
     )
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     if rules_dataframe is None:
         rules_dataframe = model_bpa_rules()
@@ -951,7 +949,7 @@ def run_model_bpa(
     dfD["Has Date Table"] = any(
         (r["Parent Data Category"] == "Time")
         & (r["Data Type"] == "DateTime")
-        & (r["Key"] is True)
+        & (r["Key"] == True)
         for i, r in dfC.iterrows()
     )
     # dfC['In Date Table'] = dfC['Table Name'].isin(dfT.loc[dfT['Data Category'] == "Time", 'Name'])
@@ -1033,7 +1031,7 @@ def run_model_bpa(
                     dfM.at[i, "Has Fully Qualified Measure Reference"] = True
 
     dfR["Inactive without USERELATIONSHIP"] = False
-    for i, r in dfR[dfR["Active"] is False].iterrows():
+    for i, r in dfR[dfR["Active"] == False].iterrows():
         fromTable = r["From Table"]
         fromColumn = r["From Column"]
         toTable = r["To Table"]
@@ -1184,10 +1182,8 @@ def run_model_bpa(
     if export:
         lakeAttach = lakehouse_attached()
         if lakeAttach is False:
-            print(
-                f"In order to save the Best Practice Analyzer results, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
-            )
-            return
+            raise ValueError(f"{icons.red_dot} In order to save the Best Practice Analyzer results, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook.")
+
         dfExport = finalDF.copy()
         delta_table_name = "modelbparesults"
 
@@ -1230,7 +1226,7 @@ def run_model_bpa(
         spark_df = spark.createDataFrame(dfExport)
         spark_df.write.mode("append").format("delta").saveAsTable(delta_table_name)
         print(
-            f"\u2022 Model Best Practice Analyzer results for the '{dataset}' semantic model have been appended to the '{delta_table_name}' delta table."
+            f"{icons.green_dot} Model Best Practice Analyzer results for the '{dataset}' semantic model have been appended to the '{delta_table_name}' delta table."
         )
 
     if return_dataframe:

sempy_labs/_model_dependencies.py

@@ -25,9 +25,7 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
         Shows all dependencies for all measures in the semantic model.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     dep = fabric.evaluate_dax(
         dataset=dataset,
@@ -63,11 +61,11 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
         axis=1,
     )
 
-    while any(df["Done"] is False):
+    while any(df["Done"] == False):
         for i, r in df.iterrows():
             rObjFull = r["Referenced Full Object Name"]
             rObj = r["Referenced Object"]
-            if r["Done"] is False:
+            if r["Done"] == False:
                 dep_filt = dep[dep["Full Object Name"] == rObjFull]
 
                 for index, dependency in dep_filt.iterrows():
@@ -150,9 +148,7 @@ def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
         Shows all dependencies for all objects in the semantic model.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     dep = fabric.evaluate_dax(
         dataset=dataset,
@@ -191,11 +187,11 @@ def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
         lambda row: False if row["Referenced Object Type"] in objs else True, axis=1
     )
 
-    while any(df["Done"] is False):
+    while any(df["Done"] == False):
         for i, r in df.iterrows():
             rObjFull = r["Referenced Full Object Name"]
             rObj = r["Referenced Object"]
-            if r["Done"] is False:
+            if r["Done"] == False:
                 dep_filt = dep[dep["Full Object Name"] == rObjFull]
 
                 for index, dependency in dep_filt.iterrows():
@@ -282,9 +278,7 @@ def measure_dependency_tree(
 
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     dfM = fabric.list_measures(dataset=dataset, workspace=workspace)
     dfM_filt = dfM[dfM["Measure Name"] == measure_name]

sempy_labs/_one_lake_integration.py

@@ -42,10 +42,7 @@ def export_model_to_onelake(
     dfD_filt = dfD[dfD["Dataset Name"] == dataset]
 
     if len(dfD_filt) == 0:
-        print(
-            f"{icons.red_dot} The '{dataset}' semantic model does not exist in the '{workspace}' workspace."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model does not exist in the '{workspace}' workspace.")
 
     tmsl = f"""
     {{
@@ -104,7 +101,7 @@ def export_model_to_onelake(
         dfP_filt = dfP[
             (dfP["Mode"] == "Import")
             & (dfP["Source Type"] != "CalculationGroup")
-            & (dfP["Parent System Managed"] is False)
+            & (dfP["Parent System Managed"] == False)
         ]
         dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
         tmc = pd.DataFrame(dfP.groupby("Table Name")["Mode"].nunique()).reset_index()

sempy_labs/_query_scale_out.py

@@ -44,10 +44,7 @@ def qso_sync(dataset: str, workspace: Optional[str] = None):
             f"{icons.green_dot} QSO sync initiated for the '{dataset}' semantic model within the '{workspace}' workspace."
         )
     else:
-        print(
-            f"{icons.red_dot} QSO sync failed for the '{dataset}' semantic model within the '{workspace}' workspace."
-        )
-
+        raise ValueError(f"{icons.red_dot} QSO sync failed for the '{dataset}' semantic model within the '{workspace}' workspace.")
 
 def qso_sync_status(dataset: str, workspace: Optional[str] = None):
     """
@@ -189,7 +186,7 @@ def disable_qso(dataset: str, workspace: Optional[str] = None):
         )
         return df
     else:
-        return f"{icons.red_dot} {response.status_code}"
+        raise ValueError(f"{icons.red_dot} {response.status_code}")
 
 
 def set_qso(
@@ -256,16 +253,9 @@ def set_qso(
             )
             return df
         else:
-            return f"{icons.red_dot} {response.status_code}"
+            raise ValueError(f"{icons.red_dot} {response.status_code}")
     else:
-        print(
-            f"{icons.red_dot} Failed to set the '{dataset}' semantic model within the '{workspace}' workspace to large semantic model storage format. This is a prerequisite for enabling Query Scale Out."
-        )
-        print(
-            "https://learn.microsoft.com/power-bi/enterprise/service-premium-scale-out#prerequisites"
-        )
-        return
-
+        raise ValueError(f"{icons.red_dot} Failed to set the '{dataset}' semantic model within the '{workspace}' workspace to large semantic model storage format. This is a prerequisite for enabling Query Scale Out.\n\"https://learn.microsoft.com/power-bi/enterprise/service-premium-scale-out#prerequisites\"")
 
 def set_semantic_model_storage_format(
     dataset: str, storage_format: str, workspace: Optional[str] = None
@@ -311,10 +301,7 @@ def set_semantic_model_storage_format(
     elif storage_format == "Small":
         request_body = {"targetStorageMode": "Abf"}
     else:
-        print(
-            f"{icons.red_dot} Invalid storage format value. Valid options: {storageFormats}."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} Invalid storage format value. Valid options: {storageFormats}.")
 
     client = fabric.PowerBIRestClient()
     response = client.patch(
@@ -326,8 +313,7 @@ def set_semantic_model_storage_format(
             f"{icons.green_dot} Semantic model storage format set to '{storage_format}'."
         )
     else:
-        return f"{icons.red_dot} {response.status_code}"
-
+        raise ValueError(f"{icons.red_dot} {response.status_code}")
 
 def list_qso_settings(dataset: Optional[str] = None, workspace: Optional[str] = None):
     """
@@ -370,21 +356,17 @@ def list_qso_settings(dataset: Optional[str] = None, workspace: Optional[str] =
     client = fabric.PowerBIRestClient()
     response = client.get(f"/v1.0/myorg/groups/{workspace_id}/datasets")
     for v in response.json()["value"]:
-        tsm = v["targetStorageMode"]
+        tsm = v.get("targetStorageMode")
         if tsm == "Abf":
             sm = "Small"
         else:
             sm = "Large"
         new_data = {
-            "Dataset Id": v["id"],
-            "Dataset Name": v["name"],
+            "Dataset Id": v.get("id"),
+            "Dataset Name": v.get("name"),
             "Storage Mode": sm,
-            "QSO Auto Sync Enabled": v["queryScaleOutSettings"][
-                "autoSyncReadOnlyReplicas"
-            ],
-            "QSO Max Read Only Replicas": v["queryScaleOutSettings"][
-                "maxReadOnlyReplicas"
-            ],
+            "QSO Auto Sync Enabled": v.get("queryScaleOutSettings",{}).get("autoSyncReadOnlyReplicas"),
+            "QSO Max Read Only Replicas": v.get("queryScaleOutSettings",{}).get("maxReadOnlyReplicas"),
         }
         df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
@@ -444,4 +426,4 @@ def set_workspace_default_storage_format(
             f"{icons.green_dot} The default storage format for the '{workspace}' workspace has been updated to '{storage_format}."
         )
     else:
-        print(f"{icons.red_dot} {response.status_code}")
+        raise ValueError(f"{icons.red_dot} {response.status_code}")

sempy_labs/_refresh_semantic_model.py

@@ -41,9 +41,7 @@ def refresh_semantic_model(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+    workspace = fabric.resolve_workspace_name(workspace)
 
     if refresh_type is None:
         refresh_type = "full"
@@ -81,10 +79,7 @@ def refresh_semantic_model(
     ]
 
     if refresh_type not in refreshTypes:
-        print(
-            f"{icons.red_dot} Invalid refresh type. Refresh type must be one of these values: {refreshTypes}."
-        )
-        return
+        raise ValueError(f"{icons.red_dot} Invalid refresh type. Refresh type must be one of these values: {refreshTypes}.")
 
     if len(objects) == 0:
         requestID = fabric.refresh_dataset(
@@ -119,10 +114,7 @@ def refresh_semantic_model(
         if status == "Completed":
             break
         elif status == "Failed":
-            print(
-                f"{icons.red_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has failed."
-            )
-            return
+            raise ValueError(f"{icons.red_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has failed.")
         elif status == "Cancelled":
             print(
                 f"{icons.yellow_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has been cancelled."
@@ -163,10 +155,8 @@ def cancel_dataset_refresh(
 
     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."
-            )
-            return
+            raise ValueError(f"{icons.red_dot} There are no active Enhanced API refreshes of the '{dataset}' semantic model within the '{workspace}' workspace.")
+
         request_id = rr_filt["Request Id"].iloc[0]
 
     dataset_id = resolve_dataset_id(dataset=dataset, 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 sempy_labs.tom import connect_semantic_model
 
     if isinstance(languages, str):
         languages = [languages]

sempy_labs/_vertipaq.py

@@ -56,9 +56,7 @@ def vertipaq_analyzer(
         "ignore", message="createDataFrame attempted Arrow optimization*"
     )
 
-    if workspace is 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
@@ -102,9 +100,7 @@ def vertipaq_analyzer(
             dfI_filt = dfI[(dfI["Id"] == sqlEndpointId)]
 
             if len(dfI_filt) == 0:
-                print(
-                    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."
-                )
+                raise ValueError(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]
 
@@ -437,10 +433,7 @@ def vertipaq_analyzer(
     if export in ["table", "zip"]:
         lakeAttach = lakehouse_attached()
         if lakeAttach is False:
-            print(
-                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
+            raise ValueError(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.")            
 
     if export == "table":
         spark = SparkSession.builder.getOrCreate()

sempy_labs/directlake/_directlake_schema_compare.py

@@ -40,9 +40,7 @@ def direct_lake_schema_compare(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    if workspace is 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
@@ -57,14 +55,10 @@ def direct_lake_schema_compare(
     dfI_filt = dfI[(dfI["Id"] == sqlEndpointId)]
 
     if len(dfI_filt) == 0:
-        print(
-            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
+        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"{icons.red_dot} 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)

sempy_labs/directlake/_directlake_schema_sync.py

@@ -46,8 +46,7 @@ def direct_lake_schema_sync(
     import Microsoft.AnalysisServices.Tabular as TOM
     import System
 
-    if workspace is None:
-        workspace = fabric.resolve_workspace_name()
+    workspace = fabric.resolve_workspace_name(workspace)
 
     if lakehouse_workspace is None:
         lakehouse_workspace = workspace
@@ -62,10 +61,7 @@ def direct_lake_schema_sync(
     dfI_filt = dfI[(dfI["Id"] == sqlEndpointId)]
 
     if len(dfI_filt) == 0:
-        print(
-            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
+        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"]

sempy_labs/directlake/_fallback.py

@@ -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 is 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"{icons.yellow_dot} 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_shared_expression.py

@@ -1,9 +1,6 @@
 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
@@ -30,7 +27,7 @@ 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)
+    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"{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
+        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,7 +4,7 @@ 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 <https://learn.microsoft.com/power-bi/enterprise/directlake-overview>`_.
 
@@ -44,9 +44,7 @@ def get_sku_size(workspace: Optional[str] = None):
         The SKU size for a workspace.
     """
 
-    if workspace is 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,7 +60,7 @@ 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 sku_size parameter.*

sempy_labs/directlake/_list_directlake_model_calc_tables.py

@@ -8,7 +8,7 @@ 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).
 
@@ -27,8 +27,7 @@ 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 is None:
-        workspace = fabric.resolve_workspace_name()
+    workspace = fabric.resolve_workspace_name(workspace)
 
     df = pd.DataFrame(columns=["Table Name", "Source Expression"])
 
@@ -39,7 +38,7 @@ def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] =
         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.")
+            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)

sempy_labs/directlake/_show_unsupported_directlake_objects.py

@@ -30,8 +30,7 @@ def show_unsupported_direct_lake_objects(
 
     pd.options.mode.chained_assignment = None
 
-    if workspace is None:
-        workspace = fabric.resolve_workspace_name()
+    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

@@ -40,7 +40,7 @@ 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 is None:
         lakehouse_workspace = workspace
@@ -54,17 +54,13 @@ def update_direct_lake_model_lakehouse_connection(
     dfI_filt = dfI[(dfI["Display Name"] == lakehouse)]
 
     if len(dfI_filt) == 0:
-        print(
-            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."
-        )
+        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"{icons.yellow_dot} 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