semantic-link-labs 0.9.6__py3-none-any.whl → 0.9.7__py3-none-any.whl

sempy_labs/_helper_functions.py

@@ -183,7 +183,7 @@ def resolve_report_name(report_id: UUID, workspace: Optional[str | UUID] = None)
         The name of the Power BI report.
     """
 
-    return resolve_item_name(item_id=report_id, type="Report", workspace=workspace)
+    return resolve_item_name(item_id=report_id, workspace=workspace)
 
 
 def delete_item(
@@ -469,9 +469,7 @@ def resolve_dataset_name(
         The name of the semantic model.
     """
 
-    return resolve_item_name(
-        item_id=dataset_id, type="SemanticModel", workspace=workspace
-    )
+    return resolve_item_name(item_id=dataset_id, workspace=workspace)
 
 
 def resolve_lakehouse_name(
@@ -503,9 +501,7 @@ def resolve_lakehouse_name(
                 f"{icons.red_dot} Cannot resolve a lakehouse. Please enter a valid lakehouse or make sure a lakehouse is attached to the notebook."
             )
 
-    return resolve_item_name(
-        item_id=lakehouse_id, type="Lakehouse", workspace=workspace
-    )
+    return resolve_item_name(item_id=lakehouse_id, workspace=workspace)
 
 
 def resolve_lakehouse_id(
@@ -900,6 +896,113 @@ def resolve_workspace_name_and_id(
     return workspace_name, workspace_id
 
 
+def resolve_item_id(
+    item: str | UUID, type: Optional[str] = None, workspace: Optional[str | UUID] = None
+) -> UUID:
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    item_id = None
+
+    if _is_valid_uuid(item):
+        # Check (optional)
+        item_id = item
+        try:
+            _base_api(
+                request=f"/v1/workspaces/{workspace_id}/items/{item_id}",
+                client="fabric_sp",
+            )
+        except FabricHTTPException:
+            raise ValueError(
+                f"{icons.red_dot} The '{item_id}' item was not found in the '{workspace_name}' workspace."
+            )
+    else:
+        if type is None:
+            raise ValueError(
+                f"{icons.red_dot} The 'type' parameter is required if specifying an item name."
+            )
+        responses = _base_api(
+            request=f"/v1/workspaces/{workspace_id}/items?type={type}",
+            client="fabric_sp",
+            uses_pagination=True,
+        )
+        for r in responses:
+            for v in r.get("value", []):
+                display_name = v.get("displayName")
+                if display_name == item:
+                    item_id = v.get("id")
+                    break
+
+    if item_id is None:
+        raise ValueError(
+            f"{icons.red_dot} There's no item '{item}' of type '{type}' in the '{workspace_name}' workspace."
+        )
+
+    return item_id
+
+
+def resolve_item_name_and_id(
+    item: str | UUID, type: Optional[str] = None, workspace: Optional[str | UUID] = None
+) -> Tuple[str, UUID]:
+
+    workspace_id = resolve_workspace_id(workspace)
+    item_id = resolve_item_id(item=item, type=type, workspace=workspace_id)
+    item_name = (
+        _base_api(
+            request=f"/v1/workspaces/{workspace_id}/items/{item_id}", client="fabric_sp"
+        )
+        .json()
+        .get("displayName")
+    )
+
+    return item_name, item_id
+
+
+def resolve_item_name(item_id: UUID, workspace: Optional[str | UUID] = None) -> str:
+
+    workspace_id = resolve_workspace_id(workspace)
+    try:
+        item_name = (
+            _base_api(
+                request=f"/v1/workspaces/{workspace_id}/items/{item_id}",
+                client="fabric_sp",
+            )
+            .json()
+            .get("displayName")
+        )
+    except FabricHTTPException:
+        raise ValueError(
+            f"{icons.red_dot} The '{item_id}' item was not found in the '{workspace_id}' workspace."
+        )
+
+    return item_name
+
+
+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 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:
+        lakehouse_name = lakehouse
+        lakehouse_id = fabric.resolve_item_id(
+            item_name=lakehouse, type=type, workspace=workspace_id
+        )
+
+    return lakehouse_name, lakehouse_id
+
+
 def _extract_json(dataframe: pd.DataFrame) -> dict:
 
     payload = dataframe["payload"].iloc[0]
@@ -1308,10 +1411,8 @@ class FabricTokenCredential(TokenCredential):
 
         import notebookutils
 
-        token = notebookutils.credentials.getToken(scopes)
-        access_token = AccessToken(token, 0)
-
-        return access_token
+        token = notebookutils.credentials.getToken("storage")
+        return AccessToken(token, 0)
 
 
 def _get_adls_client(account_name):
@@ -1320,11 +1421,21 @@ def _get_adls_client(account_name):
 
     account_url = f"https://{account_name}.dfs.core.windows.net"
 
-    service_client = DataLakeServiceClient(
-        account_url, credential=FabricTokenCredential()
+    return DataLakeServiceClient(account_url, credential=FabricTokenCredential())
+
+
+def _get_blob_client(workspace_id: UUID, item_id: UUID):
+
+    from azure.storage.blob import BlobServiceClient
+
+    endpoint = _get_fabric_context_setting(name="trident.onelake.endpoint").replace(
+        ".dfs.", ".blob."
     )
+    url = f"https://{endpoint}/{workspace_id}/{item_id}"
+
+    # account_url = f"https://{account_name}.blob.core.windows.net"
 
-    return service_client
+    return BlobServiceClient(url, credential=FabricTokenCredential())
 
 
 def resolve_warehouse_id(
@@ -1889,7 +2000,9 @@ def _run_spark_sql_query(query):
     return spark.sql(query)
 
 
-def _mount(lakehouse, workspace) -> str:
+def _mount(
+    lakehouse: Optional[str | UUID] = None, workspace: Optional[str | UUID] = None
+) -> str:
     """
     Mounts a lakehouse to a notebook if it is not already mounted. Returns the local path to the lakehouse.
     """
@@ -1901,6 +2014,16 @@ def _mount(lakehouse, workspace) -> str:
         lakehouse=lakehouse, workspace=workspace
     )
 
+    # Hide display mounts
+    current_setting = ""
+    try:
+        current_setting = notebookutils.conf.get(
+            "spark.notebookutils.displaymountpoint.enabled"
+        )
+        notebookutils.conf.set("spark.notebookutils.displaymountpoint.enabled", "false")
+    except Exception:
+        pass
+
     lake_path = create_abfss_path(lakehouse_id, workspace_id)
     mounts = notebookutils.fs.mounts()
     mount_point = f"/{workspace_name.replace(' ', '')}{lakehouse_name.replace(' ', '')}"
@@ -1912,6 +2035,16 @@ def _mount(lakehouse, workspace) -> str:
         )
 
     mounts = notebookutils.fs.mounts()
+
+    # Set display mounts to original setting
+    try:
+        if current_setting != "false":
+            notebookutils.conf.set(
+                "spark.notebookutils.displaymountpoint.enabled", "true"
+            )
+    except Exception:
+        pass
+
     local_path = next(
         i.get("localPath") for i in mounts if i.get("source") == lake_path
     )
@@ -2015,3 +2148,26 @@ def _get_or_create_warehouse(
     )
 
     return (warehouse, warehouse_id)
+
+
+def _xml_to_dict(element):
+    data = {element.tag: {} if element.attrib else None}
+    children = list(element)
+    if children:
+        temp_dict = {}
+        for child in children:
+            child_dict = _xml_to_dict(child)
+            for key, value in child_dict.items():
+                if key in temp_dict:
+                    if isinstance(temp_dict[key], list):
+                        temp_dict[key].append(value)
+                    else:
+                        temp_dict[key] = [temp_dict[key], value]
+                else:
+                    temp_dict[key] = value
+        data[element.tag] = temp_dict
+    else:
+        data[element.tag] = (
+            element.text.strip() if element.text and element.text.strip() else None
+        )
+    return data

sempy_labs/_icons.py

@@ -1,6 +1,6 @@
-green_dot = "\U0001F7E2"
-yellow_dot = "\U0001F7E1"
-red_dot = "\U0001F534"
+green_dot = "\U0001f7e2"
+yellow_dot = "\U0001f7e1"
+red_dot = "\U0001f534"
 in_progress = "⌛"
 checked = "\u2611"
 unchecked = "\u2610"
@@ -8,11 +8,11 @@ start_bold = "\033[1m"
 end_bold = "\033[0m"
 bullet = "\u2022"
 warning = "⚠️"
-error = "\u274C"
+error = "\u274c"
 info = "ℹ️"
 measure_icon = "\u2211"
-table_icon = "\u229E"
-column_icon = "\u229F"
+table_icon = "\u229e"
+column_icon = "\u229f"
 model_bpa_name = "ModelBPA"
 report_bpa_name = "ReportBPA"
 severity_mapping = {warning: "Warning", error: "Error", info: "Info"}

sempy_labs/_list_functions.py

@@ -1476,7 +1476,9 @@ def list_server_properties(workspace: Optional[str | UUID] = None) -> pd.DataFra
         A pandas dataframe showing a list of the server properties.
     """
 
-    tom_server = fabric.create_tom_server(readonly=True, workspace=workspace)
+    tom_server = fabric.create_tom_server(
+        dataset=None, readonly=True, workspace=workspace
+    )
 
     rows = [
         {

sempy_labs/_model_bpa_bulk.py

@@ -2,7 +2,6 @@ import sempy.fabric as fabric
 import pandas as pd
 import datetime
 from sempy_labs._helper_functions import (
-    resolve_lakehouse_name,
     save_as_delta_table,
     resolve_workspace_capacity,
     retry,
@@ -26,7 +25,7 @@ def run_model_bpa_bulk(
     rules: Optional[pd.DataFrame] = None,
     extended: bool = False,
     language: Optional[str] = None,
-    workspace: Optional[str | List[str]] = None,
+    workspace: Optional[str | UUID | List[str | UUID]] = None,
     skip_models: Optional[str | List[str]] = ["ModelBPA", "Fabric Capacity Metrics"],
     skip_models_in_workspace: Optional[dict] = None,
 ):
@@ -44,8 +43,8 @@ def run_model_bpa_bulk(
     language : str, default=None
         The language (code) in which the rules will appear. For example, specifying 'it-IT' will show the Rule Name, Category and Description in Italian.
         Defaults to None which resolves to English.
-    workspace : str | List[str], default=None
-        The workspace or list of workspaces to scan.
+    workspace : str | uuid.UUID | List[str | uuid.UUID], default=None
+        The workspace or list of workspaces to scan. Supports both the workspace name and the workspace id.
         Defaults to None which scans all accessible workspaces.
     skip_models : str | List[str], default=['ModelBPA', 'Fabric Capacity Metrics']
         The semantic models to always skip when running this analysis.
@@ -71,7 +70,7 @@ def run_model_bpa_bulk(
     output_table = "modelbparesults"
     lakeT = get_lakehouse_tables()
     lakeT_filt = lakeT[lakeT["Table Name"] == output_table]
-    if len(lakeT_filt) == 0:
+    if lakeT_filt.empty:
         runId = 1
     else:
         max_run_id = _get_column_aggregate(table_name=output_table)
@@ -84,14 +83,14 @@ def run_model_bpa_bulk(
     if workspace is None:
         dfW_filt = dfW.copy()
     else:
-        dfW_filt = dfW[dfW["Name"].isin(workspace)]
+        dfW_filt = dfW[(dfW["Name"].isin(workspace)) | (dfW["Id"].isin(workspace))]
 
-    if len(dfW_filt) == 0:
+    if dfW_filt.empty:
         raise ValueError(
             f"{icons.red_dot} There are no valid workspaces to assess. This is likely due to not having proper permissions to the workspace(s) entered in the 'workspace' parameter."
         )
 
-    for i, r in dfW_filt.iterrows():
+    for _, r in dfW_filt.iterrows():
         wksp = r["Name"]
         wksp_id = r["Id"]
         capacity_id, capacity_name = resolve_workspace_capacity(workspace=wksp)
@@ -106,7 +105,7 @@ def run_model_bpa_bulk(
             dfD = dfD[~dfD["Dataset Name"].isin(skip_models_wkspc)]
 
         # Exclude default semantic models
-        if len(dfD) > 0:
+        if not dfD.empty:
             dfI = fabric.list_items(workspace=wksp)
             filtered_df = dfI.groupby("Display Name").filter(
                 lambda x: set(["Warehouse", "SemanticModel"]).issubset(set(x["Type"]))
@@ -116,7 +115,7 @@ def run_model_bpa_bulk(
             skip_models.extend(default_semantic_models)
             dfD_filt = dfD[~dfD["Dataset Name"].isin(skip_models)]
 
-            if len(dfD_filt) > 0:
+            if not dfD_filt.empty:
                 for _, r2 in dfD_filt.iterrows():
                     dataset_id = r2["Dataset Id"]
                     dataset_name = r2["Dataset Name"]
@@ -159,7 +158,7 @@ def run_model_bpa_bulk(
                         )
                         print(e)
 
-                if len(df) == 0:
+                if df.empty:
                     print(
                         f"{icons.yellow_dot} No BPA results to save for the '{wksp}' workspace."
                     )

sempy_labs/_model_bpa_rules.py

@@ -556,7 +556,7 @@ def model_bpa_rules(
                 "Warning",
                 "Use the DIVIDE function for division",
                 lambda obj, tom: re.search(
-                    r"\]\s*\/(?!\/)(?!\*)\" or \"\)\s*\/(?!\/)(?!\*)",
+                    r"\]\s*\/(?!\/)(?!\*)|\)\s*\/(?!\/)(?!\*)",
                     obj.Expression,
                     flags=re.IGNORECASE,
                 ),

sempy_labs/admin/_basic_functions.py

@@ -350,14 +350,40 @@ def list_workspace_access_details(
     return df
 
 
+def _resolve_workspace_name(workspace_id: Optional[UUID] = None) -> str:
+    from sempy_labs._helper_functions import _get_fabric_context_setting
+    from sempy.fabric.exceptions import FabricHTTPException
+
+    if workspace_id is None:
+        workspace_id = _get_fabric_context_setting(name="trident.workspace.id")
+
+    try:
+        workspace_name = (
+            _base_api(
+                request=f"/v1/admin/workspaces/{workspace_id}", client="fabric_sp"
+            )
+            .json()
+            .get("name")
+        )
+    except FabricHTTPException:
+        raise ValueError(
+            f"{icons.red_dot} The '{workspace_id}' workspace was not found."
+        )
+    return workspace_name
+
+
 def _resolve_workspace_name_and_id(
     workspace: str | UUID,
 ) -> Tuple[str, UUID]:
 
-    from sempy_labs._helper_functions import resolve_workspace_name_and_id
+    from sempy_labs._helper_functions import _get_fabric_context_setting
 
     if workspace is None:
-        (workspace_name, workspace_id) = resolve_workspace_name_and_id()
+        workspace_id = _get_fabric_context_setting(name="trident.workspace.id")
+        workspace_name = _resolve_workspace_name(workspace_id)
+    elif _is_valid_uuid(workspace):
+        workspace_id = workspace
+        workspace_name = _resolve_workspace_name(workspace_id)
     else:
         dfW = list_workspaces(workspace=workspace)
         if not dfW.empty:

sempy_labs/admin/_reports.py

@@ -113,7 +113,7 @@ def list_report_users(report: str | UUID) -> pd.DataFrame:
     """
     Shows a list of users that have access to the specified report.
 
-    This is a wrapper function for the following API: `Admin - Reports GetDatasetUsersAsAdmin <https://learn.microsoft.com/rest/api/power-bi/admin/datasets-get-report-users-as-admin>`_.
+    This is a wrapper function for the following API: `Admin - Reports GetDatasetUsersAsAdmin <https://learn.microsoft.com/rest/api/power-bi/admin/reports-get-report-users-as-admin>`_.
 
     Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
 

sempy_labs/admin/_scanner.py

@@ -115,6 +115,4 @@ def scan_workspaces(
         client="fabric_sp",
     )
 
-    print(f"{icons.green_dot} Status: {scan_status}")
-
     return response.json()

sempy_labs/admin/_tenant.py

@@ -126,11 +126,10 @@ def list_capacity_tenant_settings_overrides(
             if capacity_id is None:
                 # If capacity_id is None, we access 'Overrides' -> 'tenantSettings'
                 for override in r.get("overrides", []):
+                    capacity_id = override.get("id")
                     tenant_settings = override.get("tenantSettings", [])
                     for setting in tenant_settings:
-                        data.append(
-                            create_new_data(setting)
-                        )  # No capacity_id needed here
+                        data.append(create_new_data(setting, capacity_id))
             else:
                 # If capacity_id is provided, we access 'value' directly for tenantSettings
                 for setting in r.get("value", []):
@@ -391,6 +390,7 @@ def list_workspaces_tenant_settings_overrides() -> pd.DataFrame:
     """
 
     columns = {
+        "Workspace Id": "string",
         "Setting Name": "string",
         "Title": "string",
         "Enabled": "bool",
@@ -409,8 +409,10 @@ def list_workspaces_tenant_settings_overrides() -> pd.DataFrame:
 
     for r in responses:
         for v in r.get("value", []):
+            workspace_id = v.get("id")
             for setting in v.get("tenantSettings", []):
                 new_data = {
+                    "Workspace Id": workspace_id,
                     "Setting Name": setting.get("settingName"),
                     "Title": setting.get("title"),
                     "Enabled": setting.get("enabled"),
@@ -447,6 +449,7 @@ def list_domain_tenant_settings_overrides() -> pd.DataFrame:
     """
 
     columns = {
+        "Domain Id": "string",
         "Setting Name": "string",
         "Title": "string",
         "Enabled": "bool",
@@ -466,8 +469,10 @@ def list_domain_tenant_settings_overrides() -> pd.DataFrame:
 
     for r in responses:
         for v in r.get("value", []):
+            domain_id = v.get("id")
             for setting in v.get("tenantSettings", []):
                 new_data = {
+                    "Domain Id": domain_id,
                     "Setting Name": setting.get("settingName"),
                     "Title": setting.get("title"),
                     "Enabled": setting.get("enabled"),

sempy_labs/directlake/_generate_shared_expression.py

@@ -13,6 +13,7 @@ def generate_shared_expression(
     item_name: Optional[str] = None,
     item_type: str = "Lakehouse",
     workspace: Optional[str | UUID] = None,
+    use_sql_endpoint: bool = True,
 ) -> str:
     """
     Dynamically generates the M expression used by a Direct Lake model for a given lakehouse/warehouse.
@@ -28,6 +29,9 @@ def generate_shared_expression(
         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.
+    use_sql_endpoint : bool, default=True
+        Whether to use the SQL Endpoint for the lakehouse/warehouse.
+        If False, the expression will be generated without using the SQL Endpoint.
 
     Returns
     -------
@@ -78,4 +82,8 @@ def generate_shared_expression(
     end_expr = "\nin\n\tdatabase"
     mid_expr = f'Sql.Database("{sqlEPCS}", "{sqlepid}")'
 
-    return f"{start_expr}{mid_expr}{end_expr}"
+    # Build DL/OL expression
+    if not use_sql_endpoint and item_type == "Lakehouse":
+        return f'AzureDataLakeStorage{{"server":"onelake.dfs.fabric.microsoft.com","path":"/{workspace_id}/{item_id}/"}}'
+    else:
+        return f"{start_expr}{mid_expr}{end_expr}"