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

sempy_labs/_vertipaq.py

@@ -1,8 +1,11 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from IPython.display import display, HTML
-import zipfile, os, shutil, datetime, warnings
+import zipfile
+import os
+import shutil
+import datetime
+import warnings
 from pyspark.sql import SparkSession
 from sempy_labs._helper_functions import (
     format_dax_object_name,
@@ -12,10 +15,11 @@ from sempy_labs._helper_functions import (
 from sempy_labs._list_functions import list_relationships
 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 typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 
+
 @log
 def vertipaq_analyzer(
     dataset: str,
@@ -51,14 +55,14 @@ def vertipaq_analyzer(
 
     """
 
+    from sempy_labs.tom import connect_semantic_model
+
     pd.options.mode.copy_on_write = True
     warnings.filterwarnings(
         "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
@@ -73,18 +77,21 @@ def vertipaq_analyzer(
     dfR["From Object"] = format_dax_object_name(dfR["From Table"], dfR["From Column"])
     dfR["To Object"] = format_dax_object_name(dfR["To Table"], dfR["To Column"])
     dfP = fabric.list_partitions(dataset=dataset, extended=True, workspace=workspace)
-    dfD = fabric.list_datasets(
-        workspace=workspace,
-        additional_xmla_properties=["CompatibilityLevel", "Model.DefaultMode"],
-    )
-    dfD = dfD[dfD["Dataset Name"] == dataset]
-    dfD["Compatibility Level"] = dfD["Compatibility Level"].astype(int)
-    isDirectLake = any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows())
+
+    with connect_semantic_model(
+        dataset=dataset, readonly=True, workspace=workspace
+    ) as tom:
+        compat_level = tom.model.Model.Database.CompatibilityLevel
+        is_direct_lake = tom.is_direct_lake()
+        def_mode = tom.model.DefaultMode
+        table_count = tom.model.Tables.Count
+        column_count = len(list(tom.all_columns()))
+
     dfR["Missing Rows"] = None
 
     # Direct Lake
     if read_stats_from_data:
-        if isDirectLake:
+        if is_direct_lake:
             dfC = pd.merge(
                 dfC,
                 dfP[["Table Name", "Query", "Source Type"]],
@@ -102,8 +109,9 @@ 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]
@@ -242,7 +250,7 @@ def vertipaq_analyzer(
 
                 try:
                     missingRows = result.iloc[0, 0]
-                except:
+                except Exception:
                     pass
 
                 dfR.at[i, "Missing Rows"] = missingRows
@@ -312,7 +320,6 @@ def vertipaq_analyzer(
     )
     dfTable = pd.merge(dfTable, dfTP, on="Table Name", how="left")
     dfTable = pd.merge(dfTable, dfTC, on="Table Name", how="left")
-    dfTable = dfTable.drop_duplicates()  # Drop duplicates (temporary)
     dfTable = dfTable.sort_values(by="Total Size", ascending=False)
     dfTable.reset_index(drop=True, inplace=True)
     export_Table = dfTable.copy()
@@ -322,7 +329,7 @@ def vertipaq_analyzer(
     pctList = ["% DB"]
     dfTable[pctList] = dfTable[pctList].applymap("{:.2f}%".format)
 
-    ## Relationships
+    #  Relationships
     # dfR.drop(columns=['Max From Cardinality', 'Max To Cardinality'], inplace=True)
     dfR = pd.merge(
         dfR,
@@ -363,12 +370,17 @@ def vertipaq_analyzer(
         intList.remove("Missing Rows")
     dfR[intList] = dfR[intList].applymap("{:,}".format)
 
-    ## Partitions
+    # Partitions
     dfP = dfP[
-        ["Table Name", "Partition Name", "Mode", "Record Count", "Segment Count"]
-    ].sort_values(
-        by="Record Count", ascending=False
-    )  # , 'Records per Segment'
+        [
+            "Table Name",
+            "Partition Name",
+            "Mode",
+            "Record Count",
+            "Segment Count",
+            # "Records per Segment",
+        ]
+    ].sort_values(by="Record Count", ascending=False)
     dfP["Records per Segment"] = round(
         dfP["Record Count"] / dfP["Segment Count"], 2
     )  # Remove after records per segment is fixed
@@ -377,7 +389,7 @@ def vertipaq_analyzer(
     intList = ["Record Count", "Segment Count", "Records per Segment"]
     dfP[intList] = dfP[intList].applymap("{:,}".format)
 
-    ## Hierarchies
+    # Hierarchies
     dfH_filt = dfH[dfH["Level Ordinal"] == 0]
     dfH_filt = dfH_filt[["Table Name", "Hierarchy Name", "Used Size"]].sort_values(
         by="Used Size", ascending=False
@@ -387,7 +399,7 @@ def vertipaq_analyzer(
     intList = ["Used Size"]
     dfH_filt[intList] = dfH_filt[intList].applymap("{:,}".format)
 
-    ## Model
+    # Model
     if total_size >= 1000000000:
         y = total_size / (1024**3) * 1000000000
     elif total_size >= 1000000:
@@ -396,19 +408,14 @@ def vertipaq_analyzer(
         y = total_size / (1024) * 1000
     y = round(y)
 
-    tblCount = len(dfT)
-    colCount = len(dfC_filt)
-    compatLevel = dfD["Compatibility Level"].iloc[0]
-    defMode = dfD["Model Default Mode"].iloc[0]
-
     dfModel = pd.DataFrame(
         {
             "Dataset Name": dataset,
             "Total Size": y,
-            "Table Count": tblCount,
-            "Column Count": colCount,
-            "Compatibility Level": compatLevel,
-            "Default Mode": defMode,
+            "Table Count": table_count,
+            "Column Count": column_count,
+            "Compatibility Level": compat_level,
+            "Default Mode": def_mode,
         },
         index=[0],
     )
@@ -433,14 +440,13 @@ def vertipaq_analyzer(
 
     visualize_vertipaq(dfs)
 
-    ### Export vertipaq to delta tables in lakehouse
+    # Export vertipaq to delta tables in lakehouse
     if export in ["table", "zip"]:
         lakeAttach = lakehouse_attached()
         if lakeAttach is False:
-            print(
+            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."
             )
-            return
 
     if export == "table":
         spark = SparkSession.builder.getOrCreate()
@@ -472,7 +478,9 @@ def vertipaq_analyzer(
             "export_Model": ["Model", export_Model],
         }
 
-        print(f"{icons.in_progress} 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
@@ -494,7 +502,7 @@ def vertipaq_analyzer(
                 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
+    # Export vertipaq to zip file within the lakehouse
     if export == "zip":
         dataFrames = {
             "dfModel": dfModel,
@@ -532,7 +540,8 @@ def vertipaq_analyzer(
             if os.path.exists(filePath):
                 os.remove(filePath)
         print(
-            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."
+            f"{icons.green_dot} The Vertipaq Analyzer info for the '{dataset}' semantic model in the '{workspace}' workspace has been saved "
+            f"to the 'Vertipaq Analyzer/{zipFileName}' in the default lakehouse attached to this notebook."
         )
 
 
@@ -839,7 +848,7 @@ def visualize_vertipaq(dataframes):
                     (tooltipDF["ViewName"] == vw) & (tooltipDF["ColumnName"] == col)
                 ]
                 tt = tooltipDF_filt["Tooltip"].iloc[0]
-            except:
+            except Exception:
                 pass
             df_html = df_html.replace(f"<th>{col}</th>", f'<th title="{tt}">{col}</th>')
         content_html += (

sempy_labs/directlake/__init__.py

@@ -21,6 +21,7 @@ from sempy_labs.directlake._update_directlake_model_lakehouse_connection import
 )
 from sempy_labs.directlake._update_directlake_partition_entity import (
     update_direct_lake_partition_entity,
+    add_table_to_direct_lake_semantic_model,
 )
 from sempy_labs.directlake._warm_cache import (
     warm_direct_lake_cache_isresident,
@@ -42,4 +43,5 @@ __all__ = [
     "update_direct_lake_partition_entity",
     "warm_direct_lake_cache_isresident",
     "warm_direct_lake_cache_perspective",
+    "add_table_to_direct_lake_semantic_model",
 ]

sempy_labs/directlake/_directlake_schema_compare.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._helper_functions import (
@@ -13,6 +12,7 @@ from typing import Optional
 import sempy_labs._icons as icons
 from sempy._utils._log import log
 
+
 @log
 def direct_lake_schema_compare(
     dataset: str,
@@ -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,15 @@ 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."
+        raise ValueError(
+            f"{icons.red_dot} The SQL Endpoint in the '{dataset}' semantic model in the '{workspace} workspace does not point to the "
+            f"'{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace as specified."
         )
-        return
 
     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)
@@ -98,7 +97,8 @@ def direct_lake_schema_compare(
         )
     else:
         print(
-            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."
+            f"{icons.yellow_dot} The following tables exist in the '{dataset}' semantic model within the '{workspace}' workspace"
+            f" but do not exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingtbls)
     if len(missingcols) == 0:
@@ -107,6 +107,7 @@ def direct_lake_schema_compare(
         )
     else:
         print(
-            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."
+            f"{icons.yellow_dot} The following columns exist in the '{dataset}' semantic model within the '{workspace}' workspace "
+            f"but do not exist in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingcols)

sempy_labs/directlake/_directlake_schema_sync.py

@@ -12,6 +12,7 @@ from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 
+
 @log
 def direct_lake_schema_sync(
     dataset: str,
@@ -46,8 +47,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 +62,10 @@ 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."
+        raise ValueError(
+            f"{icons.red_dot} The SQL Endpoint in the '{dataset}' semantic model in the '{workspace} workspace does not point to the "
+            f"'{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace as specified."
         )
-        return
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     dfP_filt = dfP[dfP["Source Type"] == "Entity"]
@@ -81,21 +81,9 @@ def direct_lake_schema_sync(
     lc = get_lakehouse_columns(lakehouse, lakehouse_workspace)
     lc_filt = lc[lc["Table Name"].isin(dfP_filt["Query"].values)]
 
-    mapping = {
-        "string": "String",
-        "bigint": "Int64",
-        "int": "Int64",
-        "smallint": "Int64",
-        "boolean": "Boolean",
-        "timestamp": "DateTime",
-        "date": "DateTime",
-        "decimal(38,18)": "Decimal",
-        "double": "Double",
-    }
-
     with connect_semantic_model(
-                dataset=dataset, readonly=False, workspace=workspace
-            ) as tom:
+        dataset=dataset, readonly=False, workspace=workspace
+    ) as tom:
 
         for i, r in lc_filt.iterrows():
             lakeTName = r["Table Name"]
@@ -110,18 +98,20 @@ def direct_lake_schema_sync(
                     col = TOM.DataColumn()
                     col.Name = lakeCName
                     col.SourceColumn = lakeCName
-                    dt = mapping.get(dType)
+                    dt = icons.data_type_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
+                        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."
+                        f"{icons.green_dot} The '{lakeCName}' column has been added to the '{tName}' table as a '{dt}' "
+                        f"data type within the '{dataset}' semantic model within the '{workspace}' workspace."
                     )
                 else:
                     print(
                         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."
                     )
-            

sempy_labs/directlake/_fallback.py

@@ -1,9 +1,9 @@
-import sempy
 import sempy.fabric as fabric
 import numpy as np
-from typing import List, Optional, Union
+from typing import Optional
 import sempy_labs._icons as icons
 
+
 def check_fallback_reason(dataset: str, workspace: Optional[str] = None):
     """
     Shows the reason a table in a Direct Lake semantic model would fallback to DirectQuery.
@@ -23,16 +23,14 @@ 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(

sempy_labs/directlake/_get_directlake_lakehouse.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs._helper_functions import (
     resolve_lakehouse_id,
@@ -9,6 +8,7 @@ from typing import Optional, Tuple
 from uuid import UUID
 import sempy_labs._icons as icons
 
+
 def get_direct_lake_lakehouse(
     dataset: str,
     workspace: Optional[str] = None,

sempy_labs/directlake/_get_shared_expression.py

@@ -1,13 +1,10 @@
-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,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,9 @@ def get_shared_expression(
     provStatus = lakeDetail["SQL Endpoint Provisioning Status"].iloc[0]
 
     if provStatus == "InProgress":
-        print(
+        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."
         )
-        return
 
     sh = (
         'let\n\tdatabase = Sql.Database("'

sempy_labs/directlake/_guardrails.py

@@ -1,12 +1,12 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
-from typing import List, Optional, Union
+from typing import Optional
 
 
-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>`_.
+    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 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

@@ -1,14 +1,16 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs._list_functions import list_tables, list_annotations
+from sempy_labs._list_functions import list_tables
 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).
 
@@ -27,24 +29,26 @@ 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"])
 
     with connect_semantic_model(
-                dataset=dataset, readonly=True, workspace=workspace
-            ) as tom:
-        
+        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.")
+            raise ValueError(
+                f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode."
+            )
         else:
-            dfA = list_annotations(dataset, workspace)
+            dfA = fabric.list_annotations(dataset=dataset, workspace=workspace)
             dfT = list_tables(dataset, workspace)
             dfA_filt = dfA[
-                (dfA["Object Type"] == "Model") & (dfA["Annotation Name"].isin(dfT["Name"]))
+                (dfA["Object Type"] == "Model")
+                & (dfA["Annotation Name"].isin(dfT["Name"]))
             ]
 
             for i, r in dfA_filt.iterrows():
@@ -52,6 +56,8 @@ def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] =
                 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)
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
 
             return df

sempy_labs/directlake/_show_unsupported_directlake_objects.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._list_functions import list_tables
@@ -6,12 +5,14 @@ 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]:
     """
-    Returns a list of a semantic model's objects which are not supported by Direct Lake based on `official documentation <https://learn.microsoft.com/power-bi/enterprise/directlake-overview#known-issues-and-limitations>`_.
+    Returns a list of a semantic model's objects which are not supported by Direct Lake based on
+     `official documentation <https://learn.microsoft.com/power-bi/enterprise/directlake-overview#known-issues-and-limitations>`_.
 
     Parameters
     ----------
@@ -30,8 +31,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

@@ -1,9 +1,7 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs.directlake._get_shared_expression import get_shared_expression
 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 Optional
@@ -40,7 +38,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,16 +52,17 @@ 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. "
+            f"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(
@@ -77,4 +76,6 @@ def update_direct_lake_model_lakehouse_connection(
                     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
+                raise ValueError(
+                    f"{icons.red_dot} The expression in the '{dataset}' semantic model was not updated."
+                ) from e