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

sempy_labs/_helper_functions.py

@@ -11,8 +11,8 @@ import datetime
 from typing import Optional, Tuple, List
 from uuid import UUID
 import sempy_labs._icons as icons
-import urllib.parse
 from azure.core.credentials import TokenCredential, AccessToken
+import urllib.parse
 import numpy as np
 from IPython.display import display, HTML
 
@@ -52,6 +52,24 @@ def create_abfss_path(
     return f"abfss://{lakehouse_workspace_id}@onelake.dfs.fabric.microsoft.com/{lakehouse_id}/Tables/{delta_table_name}"
 
 
+def _get_default_file_path() -> str:
+
+    default_file_storage = _get_fabric_context_setting(name="fs.defaultFS")
+
+    return default_file_storage.split("@")[-1][:-1]
+
+
+def _split_abfss_path(path: str) -> Tuple[UUID, UUID, str]:
+
+    parsed_url = urllib.parse.urlparse(path)
+
+    workspace_id = parsed_url.netloc.split("@")[0]
+    item_id = parsed_url.path.lstrip("/").split("/")[0]
+    delta_table_name = parsed_url.path.split("/")[-1]
+
+    return workspace_id, item_id, delta_table_name
+
+
 def format_dax_object_name(table: str, column: str) -> str:
     """
     Formats a table/column combination to the 'Table Name'[Column Name] format.
@@ -102,7 +120,7 @@ def create_relationship_name(
     )
 
 
-def resolve_report_id(report: str, workspace: Optional[str] = None) -> UUID:
+def resolve_report_id(report: str, workspace: Optional[str | UUID] = None) -> UUID:
     """
     Obtains the ID of the Power BI report.
 
@@ -110,8 +128,8 @@ def resolve_report_id(report: str, workspace: Optional[str] = None) -> UUID:
     ----------
     report : str
         The name of the Power BI report.
-    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.
 
@@ -121,25 +139,19 @@ def resolve_report_id(report: str, workspace: Optional[str] = None) -> UUID:
         The ID of the Power BI report.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
-    obj = fabric.resolve_item_id(item_name=report, type="Report", workspace=workspace)
+    return fabric.resolve_item_id(item_name=report, type="Report", workspace=workspace)
 
-    return obj
 
-
-def resolve_report_name(report_id: UUID, workspace: Optional[str] = None) -> str:
+def resolve_report_name(report_id: UUID, workspace: Optional[str | UUID] = None) -> str:
     """
     Obtains the name of the Power BI report.
 
     Parameters
     ----------
-    report_id : UUID
+    report_id : uuid.UUID
         The name of the Power BI report.
-    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.
 
@@ -149,46 +161,83 @@ def resolve_report_name(report_id: UUID, workspace: Optional[str] = None) -> str
         The name of the Power BI report.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
-    obj = fabric.resolve_item_name(
+    return fabric.resolve_item_name(
         item_id=report_id, type="Report", workspace=workspace
     )
 
-    return obj
 
+def resolve_item_name_and_id(
+    item: str | UUID, type: Optional[str] = None, workspace: Optional[str | UUID] = None
+) -> Tuple[str, UUID]:
 
-def resolve_dataset_name_and_id(
-    dataset: str | UUID, workspace: Optional[str] = None
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    if _is_valid_uuid(item):
+        item_id = item
+        item_name = fabric.resolve_item_name(
+            item_id=item_id, type=type, workspace=workspace_id
+        )
+    else:
+        if type is None:
+            raise ValueError(
+                f"{icons.warning} Must specify a 'type' if specifying a name as the 'item'."
+            )
+        item_name = item
+        item_id = fabric.resolve_item_id(
+            item_name=item, type=type, workspace=workspace_id
+        )
+
+    return item_name, item_id
+
+
+def resolve_lakehouse_name_and_id(
+    lakehouse: Optional[str | UUID] = None, workspace: Optional[str | UUID] = None
 ) -> Tuple[str, UUID]:
 
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    type = "Lakehouse"
 
-    if _is_valid_uuid(dataset):
-        dataset_id = dataset
-        dataset_name = fabric.resolve_item_name(
-            item_id=dataset_id, type="SemanticModel", workspace=workspace_id
+    if lakehouse is None:
+        lakehouse_id = fabric.get_lakehouse_id()
+        lakehouse_name = fabric.resolve_item_name(
+            item_id=lakehouse_id, type=type, workspace=workspace_id
+        )
+    elif _is_valid_uuid(lakehouse):
+        lakehouse_id = lakehouse
+        lakehouse_name = fabric.resolve_item_name(
+            item_id=lakehouse_id, type=type, workspace=workspace_id
         )
     else:
-        dataset_name = dataset
-        dataset_id = fabric.resolve_item_id(
-            item_name=dataset, type="SemanticModel", workspace=workspace_id
+        lakehouse_name = lakehouse
+        lakehouse_id = fabric.resolve_item_id(
+            item_name=lakehouse, type=type, workspace=workspace_id
         )
 
+    return lakehouse_name, lakehouse_id
+
+
+def resolve_dataset_name_and_id(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> Tuple[str, UUID]:
+
+    (dataset_name, dataset_id) = resolve_item_name_and_id(
+        item=dataset, type="SemanticModel", workspace=workspace
+    )
+
     return dataset_name, dataset_id
 
 
-def resolve_dataset_id(dataset: str | UUID, workspace: Optional[str] = None) -> UUID:
+def resolve_dataset_id(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> UUID:
     """
     Obtains the ID of the semantic model.
 
     Parameters
     ----------
-    dataset : str | UUID
+    dataset : str | uuid.UUID
         The name or ID of the semantic model.
-    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.
@@ -209,15 +258,17 @@ def resolve_dataset_id(dataset: str | UUID, workspace: Optional[str] = None) ->
     return dataset_id
 
 
-def resolve_dataset_name(dataset_id: UUID, workspace: Optional[str] = None) -> str:
+def resolve_dataset_name(
+    dataset_id: UUID, workspace: Optional[str | UUID] = None
+) -> str:
     """
     Obtains the name of the semantic model.
 
     Parameters
     ----------
-    dataset_id : UUID
+    dataset_id : uuid.UUID
         The name of the semantic model.
-    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.
@@ -228,30 +279,24 @@ def resolve_dataset_name(dataset_id: UUID, workspace: Optional[str] = None) -> s
         The name of the semantic model.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
-    obj = fabric.resolve_item_name(
+    return fabric.resolve_item_name(
         item_id=dataset_id, type="SemanticModel", workspace=workspace
     )
 
-    return obj
-
 
 def resolve_lakehouse_name(
-    lakehouse_id: Optional[UUID] = None, workspace: Optional[str] = None
+    lakehouse_id: Optional[UUID] = None, workspace: Optional[str | UUID] = None
 ) -> str:
     """
     Obtains the name of the Fabric lakehouse.
 
     Parameters
     ----------
-    lakehouse_id : UUID, default=None
+    lakehouse_id : uuid.UUID, default=None
         The name of the Fabric lakehouse.
         Defaults to None which resolves to the lakehouse attached to the notebook.
-    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.
 
@@ -261,60 +306,59 @@ def resolve_lakehouse_name(
         The name of the Fabric lakehouse.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
     if lakehouse_id is None:
         lakehouse_id = fabric.get_lakehouse_id()
 
-    obj = fabric.resolve_item_name(
+    return fabric.resolve_item_name(
         item_id=lakehouse_id, type="Lakehouse", workspace=workspace
     )
 
-    return obj
-
 
-def resolve_lakehouse_id(lakehouse: str, workspace: Optional[str] = None) -> UUID:
+def resolve_lakehouse_id(
+    lakehouse: Optional[str | UUID] = None, workspace: Optional[str | UUID] = None
+) -> UUID:
     """
     Obtains the ID of the Fabric lakehouse.
 
     Parameters
     ----------
-    lakehouse : str
-        The name of the Fabric lakehouse.
-    workspace : str, default=None
-        The Fabric workspace name.
+    lakehouse : str | uuid.UUID, default=None
+        The name or ID of the Fabric lakehouse.
+    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.
 
     Returns
     -------
-    UUID
+    uuid.UUID
         The ID of the Fabric lakehouse.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
-    obj = fabric.resolve_item_id(
-        item_name=lakehouse, type="Lakehouse", workspace=workspace
-    )
+    if lakehouse is None:
+        lakehouse_id = fabric.get_lakehouse_id()
+    elif _is_valid_uuid(lakehouse):
+        lakehouse_id = lakehouse
+    else:
+        lakehouse_id = fabric.resolve_item_id(
+            item_name=lakehouse, type="Lakehouse", workspace=workspace
+        )
 
-    return obj
+    return lakehouse_id
 
 
-def get_direct_lake_sql_endpoint(dataset: str, workspace: Optional[str] = None) -> UUID:
+def get_direct_lake_sql_endpoint(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> UUID:
     """
     Obtains the SQL Endpoint ID of 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.
 
@@ -326,10 +370,6 @@ def get_direct_lake_sql_endpoint(dataset: str, workspace: Optional[str] = None)
 
     from sempy_labs.tom import connect_semantic_model
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
     # dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     # dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
 
@@ -349,7 +389,7 @@ def get_direct_lake_sql_endpoint(dataset: str, workspace: Optional[str] = None)
                 sqlEndpointId = matches[1]
 
         if sqlEndpointId is None:
-            raise ValueError("SQL Endpoint not found.")
+            raise ValueError(f"{icons.red_dot} SQL Endpoint not found.")
 
         return sqlEndpointId
 
@@ -425,8 +465,8 @@ def save_as_delta_table(
     write_mode: str,
     merge_schema: bool = False,
     schema: Optional[dict] = None,
-    lakehouse: Optional[str] = None,
-    workspace: Optional[str] = None,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Saves a pandas dataframe as a delta table in a Fabric lakehouse.
@@ -443,11 +483,11 @@ def save_as_delta_table(
         Merges the schemas of the dataframe to the delta table.
     schema : dict, default=None
         A dictionary showing the schema of the columns and their data types.
-    lakehouse : str, default=None
-        The Fabric lakehouse used by the Direct Lake semantic model.
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
         Defaults to None which resolves to the lakehouse attached to the notebook.
-    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.
     """
@@ -466,26 +506,17 @@ def save_as_delta_table(
         TimestampType,
     )
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
-
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(
-            lakehouse_id=lakehouse_id, workspace=workspace
-        )
-    else:
-        lakehouse_id = resolve_lakehouse_id(lakehouse, workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
 
-    writeModes = ["append", "overwrite"]
+    write_modes = ["append", "overwrite"]
     write_mode = write_mode.lower()
 
-    if write_mode not in writeModes:
+    if write_mode not in write_modes:
         raise ValueError(
-            f"{icons.red_dot} Invalid 'write_type' parameter. Choose from one of the following values: {writeModes}."
+            f"{icons.red_dot} Invalid 'write_type' parameter. Choose from one of the following values: {write_modes}."
         )
 
     if " " in delta_table_name:
@@ -510,16 +541,19 @@ def save_as_delta_table(
         "timestamp": TimestampType(),
     }
 
-    if schema is None:
-        spark_df = spark.createDataFrame(dataframe)
+    if isinstance(dataframe, pd.DataFrame):
+        if schema is None:
+            spark_df = spark.createDataFrame(dataframe)
+        else:
+            schema_map = StructType(
+                [
+                    StructField(column_name, type_mapping[data_type], True)
+                    for column_name, data_type in schema.items()
+                ]
+            )
+            spark_df = spark.createDataFrame(dataframe, schema_map)
     else:
-        schema_map = StructType(
-            [
-                StructField(column_name, type_mapping[data_type], True)
-                for column_name, data_type in schema.items()
-            ]
-        )
-        spark_df = spark.createDataFrame(dataframe, schema_map)
+        spark_df = dataframe
 
     filePath = create_abfss_path(
         lakehouse_id=lakehouse_id,
@@ -534,7 +568,7 @@ def save_as_delta_table(
     else:
         spark_df.write.mode(write_mode).format("delta").save(filePath)
     print(
-        f"{icons.green_dot} The dataframe has been saved as the '{delta_table_name}' table in the '{lakehouse}' lakehouse within the '{workspace}' workspace."
+        f"{icons.green_dot} The dataframe has been saved as the '{delta_table_name}' table in the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace."
     )
 
 
@@ -574,14 +608,16 @@ def language_validate(language: str):
     return lang
 
 
-def resolve_workspace_name_and_id(workspace: Optional[str] = None) -> Tuple[str, str]:
+def resolve_workspace_name_and_id(
+    workspace: Optional[str | UUID] = None,
+) -> Tuple[str, str]:
     """
     Obtains the name and ID of the Fabric workspace.
 
     Parameters
     ----------
-    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.
 
@@ -593,11 +629,15 @@ def resolve_workspace_name_and_id(workspace: Optional[str] = None) -> Tuple[str,
 
     if workspace is None:
         workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
+        workspace_name = fabric.resolve_workspace_name(workspace_id)
+    elif _is_valid_uuid(workspace):
+        workspace_id = workspace
+        workspace_name = fabric.resolve_workspace_name(workspace_id)
     else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
+        workspace_name = workspace
+        workspace_id = fabric.resolve_workspace_id(workspace_name)
 
-    return str(workspace), str(workspace_id)
+    return str(workspace_name), str(workspace_id)
 
 
 def _extract_json(dataframe: pd.DataFrame) -> dict:
@@ -618,12 +658,12 @@ def _conv_b64(file):
 
 def _decode_b64(file, format: Optional[str] = "utf-8"):
 
-    result = base64.b64decode(file).decode(format)
-
-    return result
+    return base64.b64decode(file).decode(format)
 
 
-def is_default_semantic_model(dataset: str, workspace: Optional[str] = None) -> bool:
+def is_default_semantic_model(
+    dataset: str, workspace: Optional[str | UUID] = None
+) -> bool:
     """
     Identifies whether a semantic model is a default semantic model.
 
@@ -631,8 +671,8 @@ def is_default_semantic_model(dataset: str, workspace: Optional[str] = None) ->
     ----------
     dataset : str
         The name 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.
 
@@ -642,9 +682,9 @@ def is_default_semantic_model(dataset: str, workspace: Optional[str] = None) ->
         A True/False value indicating whether the semantic model is a default semantic model.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
-    dfI = fabric.list_items(workspace=workspace)
+    dfI = fabric.list_items(workspace=workspace_id)
     filtered_df = dfI.groupby("Display Name").filter(
         lambda x: set(["Warehouse", "SemanticModel"]).issubset(set(x["Type"]))
         or set(["Lakehouse", "SemanticModel"]).issubset(set(x["Type"]))
@@ -654,16 +694,16 @@ def is_default_semantic_model(dataset: str, workspace: Optional[str] = None) ->
     return dataset in default_semantic_models
 
 
-def resolve_item_type(item_id: UUID, workspace: Optional[str] = None) -> str:
+def resolve_item_type(item_id: UUID, workspace: Optional[str | UUID] = None) -> str:
     """
     Obtains the item type for a given Fabric Item Id within a Fabric workspace.
 
     Parameters
     ----------
-    item_id : UUID
+    item_id : uuid.UUID
         The item/artifact Id.
-    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.
 
@@ -673,50 +713,43 @@ def resolve_item_type(item_id: UUID, workspace: Optional[str] = None) -> str:
         The item type for the item Id.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    dfI = fabric.list_items(workspace=workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    dfI = fabric.list_items(workspace=workspace_id)
     dfI_filt = dfI[dfI["Id"] == item_id]
 
-    if len(dfI_filt) == 0:
+    if dfI_filt.empty:
         raise ValueError(
-            f"Invalid 'item_id' parameter. The '{item_id}' item was not found in the '{workspace}' workspace."
+            f"Invalid 'item_id' parameter. The '{item_id}' item was not found in the '{workspace_name}' workspace."
         )
-    item_type = dfI_filt["Type"].iloc[0]
-
-    return item_type
+    return dfI_filt["Type"].iloc[0]
 
 
 def resolve_dataset_from_report(
-    report: str, workspace: Optional[str] = None
+    report: str | UUID, workspace: Optional[str | UUID] = None
 ) -> Tuple[UUID, str, UUID, str]:
     """
     Obtains the basic semantic model properties from which the report's data is sourced.
 
     Parameters
     ----------
-    report : str
-        The name of the Power BI report.
-    workspace : str, default=None
-        The Fabric workspace name.
+    report : str | uuid.UUID
+        The name or ID of the Power BI report.
+    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.
 
     Returns
     -------
-    Tuple[UUID, str, UUID, str]
+    Tuple[uuid.UUID, str, uuid.UUID, str]
         The semantic model UUID, semantic model name, semantic model workspace UUID, semantic model workspace name
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    from sempy_labs.report._generate_report import _get_report
 
-    dfR = fabric.list_reports(workspace=workspace)
-    dfR_filt = dfR[dfR["Name"] == report]
-    if len(dfR_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{report}' report does not exist within the '{workspace}' workspace."
-        )
-    dataset_id = dfR_filt["Dataset Id"].iloc[0]
-    dataset_workspace_id = dfR_filt["Dataset Workspace Id"].iloc[0]
+    dfR = _get_report(report=report, workspace=workspace)
+    dataset_id = dfR["Dataset Id"].iloc[0]
+    dataset_workspace_id = dfR["Dataset Workspace Id"].iloc[0]
     dataset_workspace = fabric.resolve_workspace_name(dataset_workspace_id)
     dataset_name = resolve_dataset_name(
         dataset_id=dataset_id, workspace=dataset_workspace
@@ -732,14 +765,16 @@ def _add_part(target_dict, path, payload):
     target_dict["definition"]["parts"].append(part)
 
 
-def resolve_workspace_capacity(workspace: Optional[str] = None) -> Tuple[UUID, str]:
+def resolve_workspace_capacity(
+    workspace: Optional[str | UUID] = None,
+) -> Tuple[UUID, str]:
     """
     Obtains the capacity Id and capacity name for a given workspace.
 
     Parameters
     ----------
-    workspace : str, default=None
-        The Fabric workspace name.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or UUID.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -749,9 +784,9 @@ def resolve_workspace_capacity(workspace: Optional[str] = None) -> Tuple[UUID, s
         capacity Id; capacity came.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    filter_condition = urllib.parse.quote(workspace)
-    dfW = fabric.list_workspaces(filter=f"name eq '{filter_condition}'")
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    filter_condition = urllib.parse.quote(workspace_id)
+    dfW = fabric.list_workspaces(filter=f"id eq '{filter_condition}'")
     capacity_id = dfW["Capacity Id"].iloc[0]
     dfC = fabric.list_capacities()
     dfC_filt = dfC[dfC["Id"] == capacity_id]
@@ -763,14 +798,14 @@ def resolve_workspace_capacity(workspace: Optional[str] = None) -> Tuple[UUID, s
     return capacity_id, capacity_name
 
 
-def get_capacity_id(workspace: Optional[str] = None) -> UUID:
+def get_capacity_id(workspace: Optional[str | UUID] = None) -> UUID:
     """
     Obtains the Capacity Id for a given workspace.
 
     Parameters
     ----------
-    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.
 
@@ -781,28 +816,27 @@ def get_capacity_id(workspace: Optional[str] = None) -> UUID:
     """
 
     if workspace is None:
-        capacity_id = _get_x_id(name="trident.capacity.id")
+        capacity_id = _get_fabric_context_setting(name="trident.capacity.id")
     else:
-
-        workspace = fabric.resolve_workspace_name(workspace)
-        filter_condition = urllib.parse.quote(workspace)
-        dfW = fabric.list_workspaces(filter=f"name eq '{filter_condition}'")
+        (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+        filter_condition = urllib.parse.quote(workspace_id)
+        dfW = fabric.list_workspaces(filter=f"id eq '{filter_condition}'")
         if len(dfW) == 0:
-            raise ValueError(f"{icons.red_dot} The '{workspace}' does not exist'.")
+            raise ValueError(f"{icons.red_dot} The '{workspace_name}' does not exist'.")
 
         capacity_id = dfW["Capacity Id"].iloc[0]
 
     return capacity_id
 
 
-def get_capacity_name(workspace: Optional[str] = None) -> str:
+def get_capacity_name(workspace: Optional[str | UUID] = None) -> str:
     """
     Obtains the capacity name for a given workspace.
 
     Parameters
     ----------
-    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.
 
@@ -829,7 +863,7 @@ def resolve_capacity_name(capacity_id: Optional[UUID] = None) -> str:
 
     Parameters
     ----------
-    capacity_id : UUID, default=None
+    capacity_id : uuid.UUID, default=None
         The capacity Id.
         Defaults to None which resolves to the capacity name of the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the capacity name of the workspace of the notebook.
@@ -971,7 +1005,7 @@ def resolve_deployment_pipeline_id(deployment_pipeline: str) -> UUID:
 
     Returns
     -------
-    UUID
+    uuid.UUID
         The deployment pipeline Id.
     """
 
@@ -1020,25 +1054,33 @@ def _get_adls_client(account_name):
     return service_client
 
 
-def resolve_warehouse_id(warehouse: str, workspace: Optional[str]) -> UUID:
+def resolve_warehouse_id(
+    warehouse: str | UUID, workspace: Optional[str | UUID]
+) -> UUID:
     """
     Obtains the Id for a given warehouse.
 
     Parameters
     ----------
-    warehouse : str
-        The warehouse name
+    warehouse : str | uuid.UUID
+        The warehouse name or ID.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model 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.
 
     Returns
     -------
-    UUID
+    uuid.UUID
         The warehouse Id.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    return fabric.resolve_item_id(
-        item_name=warehouse, type="Warehouse", workspace=workspace
-    )
+    if _is_valid_uuid(warehouse):
+        return warehouse
+    else:
+        return fabric.resolve_item_id(
+            item_name=warehouse, type="Warehouse", workspace=workspace
+        )
 
 
 def get_language_codes(languages: str | List[str]):
@@ -1097,7 +1139,9 @@ def convert_to_alphanumeric_lowercase(input_string):
     return cleaned_string
 
 
-def resolve_environment_id(environment: str, workspace: Optional[str] = None) -> UUID:
+def resolve_environment_id(
+    environment: str, workspace: Optional[str | UUID] = None
+) -> UUID:
     """
     Obtains the environment Id for a given environment.
 
@@ -1105,6 +1149,10 @@ def resolve_environment_id(environment: str, workspace: Optional[str] = None) ->
     ----------
     environment: str
         Name of the environment.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model 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.
 
     Returns
     -------
@@ -1112,7 +1160,6 @@ def resolve_environment_id(environment: str, workspace: Optional[str] = None) ->
         The environment Id.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
     return fabric.resolve_item_id(
         item_name=environment, type="Environment", workspace=workspace
     )
@@ -1147,7 +1194,7 @@ def convert_to_friendly_case(text: str) -> str:
     return text
 
 
-def resolve_notebook_id(notebook: str, workspace: Optional[str] = None) -> UUID:
+def resolve_notebook_id(notebook: str, workspace: Optional[str | UUID] = None) -> UUID:
     """
     Obtains the notebook Id for a given notebook.
 
@@ -1155,6 +1202,10 @@ def resolve_notebook_id(notebook: str, workspace: Optional[str] = None) -> UUID:
     ----------
     notebook: str
         Name of the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model 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.
 
     Returns
     -------
@@ -1162,7 +1213,6 @@ def resolve_notebook_id(notebook: str, workspace: Optional[str] = None) -> UUID:
         The notebook Id.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
     return fabric.resolve_item_id(
         item_name=notebook, type="Notebook", workspace=workspace
     )
@@ -1173,16 +1223,24 @@ def generate_guid():
     return str(uuid.uuid4())
 
 
-def _get_max_run_id(lakehouse: str, table_name: str) -> int:
+def _get_column_aggregate(
+    lakehouse: str,
+    table_name: str,
+    column_name: str = "RunId",
+    function: str = "max",
+    default_value: int = 0,
+) -> int:
 
     from pyspark.sql import SparkSession
 
     spark = SparkSession.builder.getOrCreate()
-    query = f"SELECT MAX(RunId) FROM {lakehouse}.{table_name}"
+    function = function.upper()
+    query = f"SELECT {function}({column_name}) FROM {lakehouse}.{table_name}"
+    if "COUNT" in function and "DISTINCT" in function:
+        query = f"SELECT COUNT(DISTINCT({column_name})) FROM {lakehouse}.{table_name}"
     dfSpark = spark.sql(query)
-    max_run_id = dfSpark.collect()[0][0] or 0
 
-    return max_run_id
+    return dfSpark.collect()[0][0] or default_value
 
 
 def _make_list_unique(my_list):
@@ -1190,22 +1248,21 @@ def _make_list_unique(my_list):
     return list(set(my_list))
 
 
-def _get_partition_map(dataset: str, workspace: Optional[str] = None) -> pd.DataFrame:
-
-    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
-    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
+def _get_partition_map(
+    dataset: str, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
 
     partitions = fabric.evaluate_dax(
-        dataset=dataset_id,
-        workspace=workspace_id,
+        dataset=dataset,
+        workspace=workspace,
         dax_string="""
     select [ID] AS [PartitionID], [TableID], [Name] AS [PartitionName] from $system.tmschema_partitions
     """,
     )
 
     tables = fabric.evaluate_dax(
-        dataset=dataset_id,
-        workspace=workspace_id,
+        dataset=dataset,
+        workspace=workspace,
         dax_string="""
     select [ID] AS [TableID], [Name] AS [TableName] from $system.tmschema_tables
     """,