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

sempy_labs/admin/_items.py

@@ -13,6 +13,7 @@ from sempy_labs._helper_functions import (
     _is_valid_uuid,
     _build_url,
 )
+import sempy_labs._authentication as auth
 
 
 def _resolve_item_id(
@@ -65,7 +66,7 @@ def _resolve_item_name_and_id(
 
 def list_items(
     capacity: Optional[str | UUID] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     state: Optional[str] = None,
     type: Optional[str] = None,
     item: Optional[str | UUID] = None,
@@ -76,11 +77,13 @@ def list_items(
 
     This is a wrapper function for the following API: `Items - List Items <https://learn.microsoft.com/rest/api/fabric/admin/items/list-items>`_.
 
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
     Parameters
     ----------
-    capacity : str | UUID, default=None
+    capacity : str | uuid.UUID, default=None
         The capacity name or id.
-    workspace : str, default=None
+    workspace : str | uuid.UUID, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
@@ -120,7 +123,7 @@ def list_items(
         ]
     )
 
-    client = fabric.FabricRestClient()
+    client = fabric.FabricRestClient(token_provider=auth.token_provider.get())
 
     params = {}
 
@@ -189,13 +192,15 @@ def list_item_access_details(
 
     This is a wrapper function for the following API: `Items - List Item Access Details <https://learn.microsoft.com/rest/api/fabric/admin/items/list-item-access-details>`_.
 
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
     Parameters
     ----------
     item : str
         Name or id of the Fabric item.
     type : str, default=None
         Type of Fabric item.
-    workspace : str, default=None
+    workspace : str | uuid.UUID, default=None
         The Fabric workspace name or id.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
@@ -217,7 +222,7 @@ def list_item_access_details(
             f"{icons.red_dot} The parameter 'item' and 'type' are mandatory."
         )
 
-    client = fabric.FabricRestClient()
+    client = fabric.FabricRestClient(token_provider=auth.token_provider.get())
 
     workspace_name, workspace_id = _resolve_workspace_name_and_id(workspace)
     item_name, item_id = _resolve_item_name_and_id(

sempy_labs/admin/_scanner.py

@@ -5,8 +5,11 @@ from sempy.fabric.exceptions import FabricHTTPException
 import numpy as np
 import time
 from sempy_labs.admin._basic_functions import list_workspaces
+from sempy._utils._log import log
+import sempy_labs._authentication as auth
 
 
+@log
 def scan_workspaces(
     data_source_details: bool = False,
     dataset_schema: bool = False,
@@ -23,6 +26,8 @@ def scan_workspaces(
         `Admin - WorkspaceInfo GetScanStatus <https://learn.microsoft.com/rest/api/power-bi/admin/workspace-info-get-scan-status>`_.
         `Admin - WorkspaceInfo GetScanResult <https://learn.microsoft.com/rest/api/power-bi/admin/workspace-info-get-scan-result>`_.
 
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
     Parameters
     ----------
     data_source_details : bool, default=False
@@ -30,12 +35,12 @@ def scan_workspaces(
     dataset_schema: bool = False
         Whether to return dataset schema (tables, columns and measures). If you set this parameter to true, you must fully enable metadata scanning in order for data to be returned. For more information, see Enable tenant settings for metadata scanning.
     dataset_expressions : bool, default=False
-        Whether to return data source details
+        Whether to return data source details.
     lineage : bool, default=False
-        Whether to return lineage info (upstream dataflows, tiles, data source IDs)
+        Whether to return lineage info (upstream dataflows, tiles, data source IDs).
     artifact_users : bool, default=False
-        Whether to return user details for a Power BI item (such as a report or a dashboard)
-    workspace : str | List[str] | UUID | List[UUID], default=None
+        Whether to return user details for a Power BI item (such as a report or a dashboard).
+    workspace : str | List[str] | uuid.UUID | List[uuid.UUID], default=None
         The required workspace name(s) or id(s) to be scanned
 
     Returns
@@ -49,7 +54,7 @@ def scan_workspaces(
         "misconfiguredDatasourceInstances": [],
     }
 
-    client = fabric.FabricRestClient()
+    client = fabric.FabricRestClient(token_provider=auth.token_provider.get())
 
     if workspace is None:
         workspace = fabric.resolve_workspace_name()

sempy_labs/directlake/_directlake_schema_compare.py

@@ -2,6 +2,8 @@ import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._helper_functions import (
     format_dax_object_name,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
 )
 from IPython.display import display
 from sempy_labs.lakehouse import get_lakehouse_columns
@@ -9,12 +11,13 @@ from sempy_labs.directlake._dl_helper import get_direct_lake_source
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy._utils._log import log
+from uuid import UUID
 
 
 @log
 def direct_lake_schema_compare(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     **kwargs,
 ):
     """
@@ -22,10 +25,10 @@ def direct_lake_schema_compare(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
@@ -41,27 +44,33 @@ def direct_lake_schema_compare(
         )
         del kwargs["lakehouse_workspace"]
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     artifact_type, lakehouse_name, lakehouse_id, lakehouse_workspace_id = (
-        get_direct_lake_source(dataset=dataset, workspace=workspace)
+        get_direct_lake_source(dataset=dataset_id, workspace=workspace_id)
     )
-    lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
 
     if artifact_type == "Warehouse":
         raise ValueError(
             f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
         )
 
-    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+    dfP = fabric.list_partitions(dataset=dataset_id, workspace=workspace_id)
 
-    if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
+    if not any(r["Mode"] == "DirectLake" for _, r in dfP.iterrows()):
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode."
+            f"{icons.red_dot} The '{dataset_name}' semantic model within the '{workspace_name}' workspace is not in Direct Lake mode."
         )
 
-    dfT = fabric.list_tables(dataset=dataset, workspace=workspace)
-    dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
+    if artifact_type is None:
+        raise ValueError(
+            f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
+        )
+
+    lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
+    dfT = fabric.list_tables(dataset=dataset_id, workspace=workspace_id)
+    dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id)
     lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)
 
     dfT.rename(columns={"Type": "Table Type"}, inplace=True)
@@ -92,7 +101,7 @@ def direct_lake_schema_compare(
         )
     else:
         print(
-            f"{icons.yellow_dot} The following tables exist in the '{dataset}' semantic model within the '{workspace}' workspace"
+            f"{icons.yellow_dot} The following tables exist in the '{dataset_name}' semantic model within the '{workspace_name}' workspace"
             f" but do not exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingtbls)
@@ -102,7 +111,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 "
+            f"{icons.yellow_dot} The following columns exist in the '{dataset_name}' semantic model within the '{workspace_name}' workspace "
             f"but do not exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
         )
         display(missingcols)

sempy_labs/directlake/_directlake_schema_sync.py

@@ -3,16 +3,21 @@ import sempy.fabric as fabric
 from sempy_labs.lakehouse import get_lakehouse_columns
 from sempy_labs.directlake._dl_helper import get_direct_lake_source
 from sempy_labs.tom import connect_semantic_model
-from sempy_labs._helper_functions import _convert_data_type
+from sempy_labs._helper_functions import (
+    _convert_data_type,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+)
 from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 @log
 def direct_lake_schema_sync(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     add_to_model: bool = False,
     **kwargs,
 ):
@@ -21,10 +26,10 @@ def direct_lake_schema_sync(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     add_to_model : bool, default=False
@@ -45,22 +50,29 @@ def direct_lake_schema_sync(
         )
         del kwargs["lakehouse_workspace"]
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     artifact_type, lakehouse_name, lakehouse_id, lakehouse_workspace_id = (
-        get_direct_lake_source(dataset=dataset, workspace=workspace)
+        get_direct_lake_source(dataset=dataset_id, workspace=workspace_id)
     )
 
     if artifact_type == "Warehouse":
         raise ValueError(
             f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
         )
+
+    if artifact_type is None:
+        raise ValueError(
+            f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
+        )
+
     lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
 
     lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)
 
     with connect_semantic_model(
-        dataset=dataset, readonly=False, workspace=workspace
+        dataset=dataset_id, readonly=False, workspace=workspace_id
     ) as tom:
 
         for i, r in lc.iterrows():
@@ -86,7 +98,7 @@ def direct_lake_schema_sync(
                     for c in tom.all_columns()
                 ):
                     print(
-                        f"{icons.yellow_dot} The '{lakeCName}' column exists in the '{lakeTName}' lakehouse table but not in the '{dataset}' semantic model within the '{workspace}' workspace."
+                        f"{icons.yellow_dot} The '{lakeCName}' column exists in the '{lakeTName}' lakehouse table but not in the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
                     )
                     if add_to_model:
                         dt = _convert_data_type(dType)
@@ -97,5 +109,5 @@ def direct_lake_schema_sync(
                             data_type=dt,
                         )
                         print(
-                            f"{icons.green_dot} The '{lakeCName}' column in the '{lakeTName}' lakehouse table was added to the '{dataset}' semantic model within the '{workspace}' workspace."
+                            f"{icons.green_dot} The '{lakeCName}' column in the '{lakeTName}' lakehouse table was added to the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
                         )

sempy_labs/directlake/_dl_helper.py

@@ -7,7 +7,6 @@ import sempy_labs._icons as icons
 from sempy._utils._log import log
 from sempy_labs._helper_functions import (
     retry,
-    resolve_dataset_id,
     resolve_lakehouse_name,
     _convert_data_type,
     resolve_dataset_name_and_id,
@@ -16,17 +15,17 @@ from sempy_labs._helper_functions import (
 
 
 def check_fallback_reason(
-    dataset: str | UUID, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> pd.DataFrame:
     """
     Shows the reason a table in a Direct Lake semantic model would fallback to DirectQuery.
 
     Parameters
     ----------
-    dataset : str | UUID
+    dataset : str | uuid.UUID
         Name or ID of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -81,9 +80,9 @@ def check_fallback_reason(
 def generate_direct_lake_semantic_model(
     dataset: str,
     lakehouse_tables: Union[str, List[str]],
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
     schema: str = "dbo",
     overwrite: bool = False,
     refresh: bool = True,
@@ -97,15 +96,15 @@ def generate_direct_lake_semantic_model(
         Name of the semantic model to be created.
     lakehouse_tables : str | List[str]
         The table(s) within the Fabric lakehouse to add to the semantic model. All columns from these tables will be added to the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name in which the semantic model will reside.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model will reside.
         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 lakehouse which stores the delta tables which will feed the Direct Lake semantic model.
         Defaults to None which resolves to the attached lakehouse.
-    lakehouse_workspace : str, default=None
-        The Fabric workspace in which the lakehouse resides.
+    lakehouse_workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the lakehouse resides.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     schema : str, default="dbo"
@@ -127,7 +126,7 @@ def generate_direct_lake_semantic_model(
     if isinstance(lakehouse_tables, str):
         lakehouse_tables = [lakehouse_tables]
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     if lakehouse_workspace is None:
         lakehouse_workspace = workspace
     if lakehouse is None:
@@ -144,23 +143,23 @@ def generate_direct_lake_semantic_model(
     for t in lakehouse_tables:
         if t not in dfLT["Table Name"].values:
             raise ValueError(
-                f"{icons.red_dot} The '{t}' table does not exist as a delta table in the '{lakehouse}' within the '{workspace}' workspace."
+                f"{icons.red_dot} The '{t}' table does not exist as a delta table in the '{lakehouse}' within the '{workspace_name}' workspace."
             )
 
     dfLC = get_lakehouse_columns(lakehouse=lakehouse, workspace=lakehouse_workspace)
     expr = generate_shared_expression(
         item_name=lakehouse, item_type="Lakehouse", workspace=lakehouse_workspace
     )
-    dfD = fabric.list_datasets(workspace=workspace)
+    dfD = fabric.list_datasets(workspace=workspace_id)
     dfD_filt = dfD[dfD["Dataset Name"] == dataset]
 
     if len(dfD_filt) > 0 and not overwrite:
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace already exists. Overwrite is set to False so the new semantic model has not been created."
+            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace_name}' workspace already exists. Overwrite is set to False so the new semantic model has not been created."
         )
 
     create_blank_semantic_model(
-        dataset=dataset, workspace=workspace, overwrite=overwrite
+        dataset=dataset, workspace=workspace_id, overwrite=overwrite
     )
 
     @retry(
@@ -169,7 +168,7 @@ def generate_direct_lake_semantic_model(
     )
     def dyn_connect():
         with connect_semantic_model(
-            dataset=dataset, readonly=True, workspace=workspace
+            dataset=dataset, readonly=True, workspace=workspace_id
         ) as tom:
 
             tom.model
@@ -178,7 +177,7 @@ def generate_direct_lake_semantic_model(
 
     expression_name = "DatabaseQuery"
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=False
+        dataset=dataset, workspace=workspace_id, readonly=False
     ) as tom:
         if not any(e.Name == expression_name for e in tom.model.Expressions):
             tom.add_expression(name=expression_name, expression=expr)
@@ -199,21 +198,21 @@ def generate_direct_lake_semantic_model(
                 )
 
     if refresh:
-        refresh_semantic_model(dataset=dataset, workspace=workspace)
+        refresh_semantic_model(dataset=dataset, workspace=workspace_id)
 
 
 def get_direct_lake_source(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> Tuple[str, str, UUID, UUID]:
     """
-    Obtains the source information for a direct lake semantic model.
+    Obtains the source information for a direct lake semantic model (if the source is located in the same workspace as the semantic model).
 
     Parameters
     ----------
-    dataset : str
-        The name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    dataset : str | uuid.UUID
+        The name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -225,34 +224,54 @@ def get_direct_lake_source(
         If the semantic model is not a Direct Lake semantic model, it will return None, None, None.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    dataset_id = resolve_dataset_id(dataset, workspace)
-    client = fabric.PowerBIRestClient()
-    request_body = {
-        "artifacts": [
-            {
-                "objectId": dataset_id,
-                "type": "dataset",
-            }
-        ]
-    }
-    response = client.post(
-        "metadata/relations/upstream?apiVersion=3", json=request_body
-    )
-
-    artifacts = response.json().get("artifacts", [])
-    sql_id, sql_object_name, sql_workspace_id, artifact_type = None, None, None, None
-
-    for artifact in artifacts:
-        object_type = artifact.get("typeName")
-        display_name = artifact.get("displayName")
-        if object_type in ["Datawarehouse", "Lakewarehouse"]:
-            artifact_type = (
-                "Warehouse" if object_type == "Datawarehouse" else "Lakehouse"
-            )
-            sql_id = artifact.get("objectId")
-            sql_workspace_id = artifact.get("workspace", {}).get("objectId")
-            sql_object_name = display_name
-            break
+    from sempy_labs._helper_functions import get_direct_lake_sql_endpoint
 
-    return artifact_type, sql_object_name, sql_id, sql_workspace_id
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    sql_endpoint_id = get_direct_lake_sql_endpoint(dataset=dataset, workspace=workspace)
+    dfI = fabric.list_items(workspace=workspace)
+    dfI_filt = dfI[(dfI["Id"] == sql_endpoint_id) & (dfI["Type"] == "SQLEndpoint")]
+
+    artifact_type, artifact_name, artifact_id = None, None, None
+
+    if not dfI_filt.empty:
+        artifact_name = dfI_filt["Display Name"].iloc[0]
+        artifact_id = dfI[
+            (dfI["Display Name"] == artifact_name)
+            & (dfI["Type"].isin(["Lakehouse", "Warehouse"]))
+        ]["Id"].iloc[0]
+        artifact_type = dfI[
+            (dfI["Display Name"] == artifact_name)
+            & (dfI["Type"].isin(["Lakehouse", "Warehouse"]))
+        ]["Type"].iloc[0]
+
+    return artifact_type, artifact_name, artifact_id, workspace_id
+
+    # client = fabric.PowerBIRestClient()
+    # request_body = {
+    #    "artifacts": [
+    #        {
+    #            "objectId": dataset_id,
+    #            "type": "dataset",
+    #        }
+    #    ]
+    # }
+    # response = client.post(
+    #    "metadata/relations/upstream?apiVersion=3", json=request_body
+    # )
+
+    # artifacts = response.json().get("artifacts", [])
+    # sql_id, sql_object_name, sql_workspace_id, artifact_type = None, None, None, None
+
+    # for artifact in artifacts:
+    #    object_type = artifact.get("typeName")
+    #    display_name = artifact.get("displayName")
+    #    if object_type in ["Datawarehouse", "Lakewarehouse"]:
+    #        artifact_type = (
+    #            "Warehouse" if object_type == "Datawarehouse" else "Lakehouse"
+    #        )
+    #        sql_id = artifact.get("objectId")
+    #        sql_workspace_id = artifact.get("workspace", {}).get("objectId")
+    #        sql_object_name = display_name
+    #        break
+
+    # return artifact_type, sql_object_name, sql_id, sql_workspace_id

sempy_labs/directlake/_generate_shared_expression.py

@@ -3,16 +3,18 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     resolve_lakehouse_id,
     resolve_warehouse_id,
+    resolve_workspace_name_and_id,
 )
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
+from uuid import UUID
 
 
 def generate_shared_expression(
     item_name: Optional[str] = None,
     item_type: str = "Lakehouse",
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ) -> str:
     """
     Dynamically generates the M expression used by a Direct Lake model for a given lakehouse/warehouse.
@@ -24,8 +26,8 @@ def generate_shared_expression(
         Defaults to None which resolves to the lakehouse attached to the notebook.
     item_type : str, default="Lakehouse"
         The Fabric item name. Valid options: 'Lakehouse', 'Warehouse'.
-    workspace : str, default=None
-        The Fabric workspace used by the item.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the item.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -35,8 +37,7 @@ def generate_shared_expression(
         Shows the expression which can be used to connect a Direct Lake semantic model to its SQL Endpoint.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    workspace_id = fabric.resolve_workspace_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     item_types = ["Lakehouse", "Warehouse"]
     item_type = item_type.capitalize()
     if item_type not in item_types:
@@ -46,11 +47,11 @@ def generate_shared_expression(
 
     if item_name is None:
         item_id = fabric.get_lakehouse_id()
-        item_name = resolve_lakehouse_name(item_id, workspace)
+        item_name = resolve_lakehouse_name(item_id, workspace_id)
     elif item_name is not None and item_type == "Lakehouse":
-        item_id = resolve_lakehouse_id(lakehouse=item_name, workspace=workspace)
+        item_id = resolve_lakehouse_id(lakehouse=item_name, workspace=workspace_id)
     elif item_type == "Warehouse":
-        item_id = resolve_warehouse_id(warehouse=item_name, workspace=workspace)
+        item_id = resolve_warehouse_id(warehouse=item_name, workspace=workspace_id)
 
     client = fabric.FabricRestClient()
     item_type_rest = f"{item_type.lower()}s"
@@ -72,7 +73,7 @@ def generate_shared_expression(
 
     if provStatus == "InProgress":
         raise ValueError(
-            f"{icons.red_dot} The SQL Endpoint for the '{item_name}' 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 '{item_name}' lakehouse within the '{workspace_name}' workspace has not yet been provisioned. Please wait until it has been provisioned."
         )
 
     start_expr = "let\n\tdatabase = "