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

sempy_labs/_refresh_semantic_model.py

@@ -5,6 +5,7 @@ from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     _get_partition_map,
     _process_and_display_chart,
+    resolve_dataset_name_and_id,
 )
 from typing import Any, List, Optional, Union
 from sempy._utils._log import log
@@ -14,11 +15,12 @@ import pandas as pd
 import warnings
 import ipywidgets as widgets
 import json
+from uuid import UUID
 
 
 @log
 def refresh_semantic_model(
-    dataset: str,
+    dataset: str | UUID,
     tables: Optional[Union[str, List[str]]] = None,
     partitions: Optional[Union[str, List[str]]] = None,
     refresh_type: str = "full",
@@ -34,8 +36,8 @@ def refresh_semantic_model(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | UUID
+        Name or ID of the semantic model.
     tables : str, List[str], default=None
         A string or a list of tables to refresh.
     partitions: str, List[str], default=None
@@ -65,7 +67,8 @@ def refresh_semantic_model(
         If 'visualize' is set to True, returns a pandas dataframe showing the SSAS trace output used to generate the visualization.
     """
 
-    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)
 
     if isinstance(tables, str):
         tables = [tables]
@@ -118,11 +121,11 @@ def refresh_semantic_model(
         def extract_failure_error():
             error_messages = []
             combined_messages = ""
-            final_message = f"{icons.red_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has failed."
+            final_message = f"{icons.red_dot} The refresh of the '{dataset_name}' semantic model within the '{workspace_name}' workspace has failed."
             for _, r in fabric.get_refresh_execution_details(
                 refresh_request_id=request_id,
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
             ).messages.iterrows():
                 error_messages.append(f"{r['Type']}: {r['Message']}")
 
@@ -135,8 +138,8 @@ def refresh_semantic_model(
         # Function to perform dataset refresh
         def refresh_dataset():
             return fabric.refresh_dataset(
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
                 refresh_type=refresh_type,
                 retry_count=retry_count,
                 apply_refresh_policy=apply_refresh_policy,
@@ -147,7 +150,9 @@ def refresh_semantic_model(
 
         def check_refresh_status(request_id):
             request_details = fabric.get_refresh_execution_details(
-                dataset=dataset, refresh_request_id=request_id, workspace=workspace
+                dataset=dataset_id,
+                refresh_request_id=request_id,
+                workspace=workspace_id,
             )
             return request_details.status
 
@@ -169,7 +174,8 @@ def refresh_semantic_model(
                     right_on="PartitionID",
                     how="left",
                 )
-                _process_and_display_chart(df, title=title, widget=widget)
+                if not df.empty:
+                    _process_and_display_chart(df, title=title, widget=widget)
                 if stop:
                     df.drop(["Object Name", "PartitionID"], axis=1, inplace=True)
                     df.rename(columns={"TableName": "Table Name"}, inplace=True)
@@ -180,7 +186,7 @@ def refresh_semantic_model(
         if not visualize:
             request_id = refresh_dataset()
         print(
-            f"{icons.in_progress} Refresh of the '{dataset}' semantic model within the '{workspace}' workspace is in progress..."
+            f"{icons.in_progress} Refresh of the '{dataset_name}' semantic model within the '{workspace_name}' workspace is in progress..."
         )
 
         # Monitor refresh progress and handle tracing if visualize is enabled
@@ -189,7 +195,7 @@ def refresh_semantic_model(
             widget = widgets.Output()
 
             with fabric.create_trace_connection(
-                dataset=dataset, workspace=workspace
+                dataset=dataset_id, workspace=workspace_id
             ) as trace_connection:
                 with trace_connection.create_trace(icons.refresh_event_schema) as trace:
                     trace.start()
@@ -204,7 +210,7 @@ def refresh_semantic_model(
                             raise ValueError(extract_failure_error())
                         elif status == "Cancelled":
                             print(
-                                f"{icons.yellow_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has been cancelled."
+                                f"{icons.yellow_dot} The refresh of the '{dataset_name}' semantic model within the '{workspace_name}' workspace has been cancelled."
                             )
                             return
 
@@ -231,7 +237,7 @@ def refresh_semantic_model(
                     )
 
                     print(
-                        f"{icons.green_dot} Refresh '{refresh_type}' of the '{dataset}' semantic model within the '{workspace}' workspace is complete."
+                        f"{icons.green_dot} Refresh '{refresh_type}' of the '{dataset_name}' semantic model within the '{workspace_name}' workspace is complete."
                     )
                     return final_df
 
@@ -245,14 +251,14 @@ def refresh_semantic_model(
                     raise ValueError(extract_failure_error())
                 elif status == "Cancelled":
                     print(
-                        f"{icons.yellow_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has been cancelled."
+                        f"{icons.yellow_dot} The refresh of the '{dataset_name}' semantic model within the '{workspace_name}' workspace has been cancelled."
                     )
                     return
 
                 time.sleep(3)
 
             print(
-                f"{icons.green_dot} Refresh '{refresh_type}' of the '{dataset}' semantic model within the '{workspace}' workspace is complete."
+                f"{icons.green_dot} Refresh '{refresh_type}' of the '{dataset_name}' semantic model within the '{workspace_name}' workspace is complete."
             )
 
     final_output = refresh_and_trace_dataset(

sempy_labs/admin/__init__.py

@@ -1,3 +1,6 @@
+from sempy_labs.admin._scanner import (
+    scan_workspaces,
+)
 from sempy_labs.admin._basic_functions import (
     assign_workspaces_to_capacity,
     unassign_workspaces_from_capacity,
@@ -66,4 +69,5 @@ __all__ = [
     "list_git_connections",
     "list_reports",
     "get_capacity_assignment_status",
+    "scan_workspaces",
 ]

sempy_labs/admin/_basic_functions.py

@@ -777,6 +777,23 @@ def list_activity_events(
             "Object Display Name",
             "Experience",
             "Refresh Enforcement Policy",
+            "Is Success",
+            "Activity Id",
+            "Item Name",
+            "Dataset Name",
+            "Report Name",
+            "Capacity Id",
+            "Capacity Name",
+            "App Name",
+            "Dataset Id",
+            "Report Id",
+            "Artifact Id",
+            "Artifact Name",
+            "Report Type",
+            "App Report Id",
+            "Distribution Method",
+            "Consumption Method",
+            "Artifact Kind",
         ]
     )
 
@@ -825,6 +842,23 @@ def list_activity_events(
                     "Object Display Name": i.get("ObjectDisplayName"),
                     "Experience": i.get("Experience"),
                     "Refresh Enforcement Policy": i.get("RefreshEnforcementPolicy"),
+                    "Is Success": i.get("IsSuccess"),
+                    "Activity Id": i.get("ActivityId"),
+                    "Item Name": i.get("ItemName"),
+                    "Dataset Name": i.get("DatasetName"),
+                    "Report Name": i.get("ReportName"),
+                    "Capacity Id": i.get("CapacityId"),
+                    "Capacity Name": i.get("CapacityName"),
+                    "App Name": i.get("AppName"),
+                    "Dataset Id": i.get("DatasetId"),
+                    "Report Id": i.get("ReportId"),
+                    "Artifact Id": i.get("ArtifactId"),
+                    "Artifact Name": i.get("ArtifactName"),
+                    "Report Type": i.get("ReportType"),
+                    "App Report Id": i.get("AppReportId"),
+                    "Distribution Method": i.get("DistributionMethod"),
+                    "Consumption Method": i.get("ConsumptionMethod"),
+                    "Artifact Kind": i.get("ArtifactKind"),
                 }
                 df = pd.concat(
                     [df, pd.DataFrame(new_data, index=[0])],

sempy_labs/admin/_scanner.py

@@ -16,12 +16,12 @@ def scan_workspaces(
     workspace: Optional[str | List[str] | UUID | List[UUID]] = None,
 ) -> dict:
     """
-    Get the inventory and details of the tenant.
+    Gets the scan result for the specified scan.
 
     This is a wrapper function for the following APIs:
-        `Admin - WorkspaceInfo PostWorkspaceInfo <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-post-workspace-info>`_.
-        `Admin - WorkspaceInfo GetScanStatus <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-get-scan-status>`_.
-        `Admin - WorkspaceInfo GetScanResult <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-get-scan-result>`_.
+        `Admin - WorkspaceInfo PostWorkspaceInfo <https://learn.microsoft.com/rest/api/power-bi/admin/workspace-info-post-workspace-info>`_.
+        `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>`_.
 
     Parameters
     ----------

sempy_labs/directlake/_dl_helper.py

@@ -10,19 +10,21 @@ from sempy_labs._helper_functions import (
     resolve_dataset_id,
     resolve_lakehouse_name,
     _convert_data_type,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
 )
 
 
 def check_fallback_reason(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str] = None
 ) -> pd.DataFrame:
     """
     Shows the reason a table in a Direct Lake semantic model would fallback to DirectQuery.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | UUID
+        Name or ID of the semantic model.
     workspace : str, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -35,19 +37,22 @@ def check_fallback_reason(
     """
     from sempy_labs.tom import connect_semantic_model
 
-    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=workspace_id
+    )
 
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=True
+        dataset=dataset_id, workspace=workspace_id, readonly=True
     ) as tom:
         if not tom.is_direct_lake():
             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."
+                f"{icons.red_dot} The '{dataset_name}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
             )
 
     df = fabric.evaluate_dax(
-        dataset=dataset,
-        workspace=workspace,
+        dataset=dataset_id,
+        workspace=workspace_id,
         dax_string="""
             SELECT [TableName] AS [Table Name],[FallbackReason] AS [FallbackReasonID]
             FROM $SYSTEM.TMSCHEMA_DELTA_TABLE_METADATA_STORAGES

sempy_labs/tom/_model.py

@@ -7,6 +7,8 @@ from sempy_labs._helper_functions import (
     format_dax_object_name,
     generate_guid,
     _make_list_unique,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
 )
 from sempy_labs._list_functions import list_relationships
 from sempy_labs._refresh_semantic_model import refresh_semantic_model
@@ -17,6 +19,7 @@ from sempy._utils._log import log
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
 import ast
+from uuid import UUID
 
 if TYPE_CHECKING:
     import Microsoft.AnalysisServices.Tabular
@@ -27,27 +30,33 @@ class TOMWrapper:
     """
     Convenience wrapper around the TOM object model for a semantic model. Always use the connect_semantic_model function to make sure the TOM object is initialized correctly.
 
-    `XMLA read/write endpoints <https://learn.microsoft.com/power-bi/enterprise/service-premium-connect-tools#to-enable-read-write-for-a-premium-capacity>`_ must
-     be enabled if setting the readonly parameter to False.
+    `XMLA read/write endpoints <https://learn.microsoft.com/power-bi/enterprise/service-premium-connect-tools#to-enable-read-write-for-a-premium-capacity>`_ must be enabled if setting the readonly parameter to False.
     """
 
-    _dataset: str
-    _workspace: str
+    _dataset_id: UUID
+    _dataset_name: str
+    _workspace_id: UUID
+    _workspace_name: str
     _readonly: bool
     _tables_added: List[str]
     _table_map = dict
     _column_map = dict
 
     def __init__(self, dataset, workspace, readonly):
-        self._dataset = dataset
-        self._workspace = workspace
+
+        (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+        (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
+        self._dataset_id = dataset_id
+        self._dataset_name = dataset_name
+        self._workspace_name = workspace_name
+        self._workspace_id = workspace_id
         self._readonly = readonly
         self._tables_added = []
 
         self._tom_server = fabric.create_tom_server(
-            readonly=readonly, workspace=workspace
+            readonly=readonly, workspace=workspace_id
         )
-        self.model = self._tom_server.Databases.GetByName(dataset).Model
+        self.model = self._tom_server.Databases[dataset_id].Model
 
         self._table_map = {}
         self._column_map = {}
@@ -2160,7 +2169,9 @@ class TOMWrapper:
             )
             """
             df = fabric.evaluate_dax(
-                dataset=self._dataset, workspace=self._workspace, dax_string=dax_query
+                dataset=self._dataset_id,
+                workspace=self._workspace_id,
+                dax_string=dax_query,
             )
             value = df["[1]"].iloc[0]
             if value != "1":
@@ -2424,7 +2435,7 @@ class TOMWrapper:
             )
         except Exception:
             raise ValueError(
-                f"{icons.red_dot} The '{measure_name}' measure does not exist in the '{self._dataset}' semantic model within the '{self._workspace}'."
+                f"{icons.red_dot} The '{measure_name}' measure does not exist in the '{self._dataset_name}' semantic model within the '{self._workspace_name}'."
             )
 
         graphics = [
@@ -2467,7 +2478,7 @@ class TOMWrapper:
                 )
             except Exception:
                 raise ValueError(
-                    f"{icons.red_dot} The '{target}' measure does not exist in the '{self._dataset}' semantic model within the '{self._workspace}'."
+                    f"{icons.red_dot} The '{target}' measure does not exist in the '{self._dataset_name}' semantic model within the '{self._workspace_name}'."
                 )
 
         if measure_target:
@@ -2793,7 +2804,7 @@ class TOMWrapper:
                     success = True
             if not success:
                 raise ValueError(
-                    f"{icons.red_dot} The '{obj}' object was not found in the '{self._dataset}' semantic model."
+                    f"{icons.red_dot} The '{obj}' object was not found in the '{self._dataset_name}' semantic model."
                 )
             else:
                 i += 1
@@ -2881,19 +2892,19 @@ class TOMWrapper:
         from sempy_labs._list_functions import list_tables
 
         dfT = list_tables(
-            dataset=self._dataset, workspace=self._workspace, extended=True
+            dataset=self._dataset_id, workspace=self._workspace_id, extended=True
         )
         dfC = fabric.list_columns(
-            dataset=self._dataset, workspace=self._workspace, extended=True
+            dataset=self._dataset_id, workspace=self._workspace_id, extended=True
         )
         dfP = fabric.list_partitions(
-            dataset=self._dataset, workspace=self._workspace, extended=True
+            dataset=self._dataset_id, workspace=self._workspace_id, extended=True
         )
         dfH = fabric.list_hierarchies(
-            dataset=self._dataset, workspace=self._workspace, extended=True
+            dataset=self._dataset_id, workspace=self._workspace_id, extended=True
         )
         dfR = list_relationships(
-            dataset=self._dataset, workspace=self._workspace, extended=True
+            dataset=self._dataset_id, workspace=self._workspace_id, extended=True
         )
 
         for t in self.model.Tables:
@@ -3338,7 +3349,9 @@ class TOMWrapper:
         usingView = False
 
         if self.is_direct_lake():
-            df = check_fallback_reason(dataset=self._dataset, workspace=self._workspace)
+            df = check_fallback_reason(
+                dataset=self._dataset_id, workspace=self._workspace_id
+            )
             df_filt = df[df["FallbackReasonID"] == 2]
 
             if len(df_filt) > 0:
@@ -3385,7 +3398,7 @@ class TOMWrapper:
 
         if rp is None:
             print(
-                f"{icons.yellow_dot} The '{table_name}' table in the '{self._dataset}' semantic model within the '{self._workspace}' workspace does not have an incremental refresh policy."
+                f"{icons.yellow_dot} The '{table_name}' table in the '{self._dataset_name}' semantic model within the '{self._workspace_name}' workspace does not have an incremental refresh policy."
             )
         else:
             print(f"Table Name: {table_name}")
@@ -3884,14 +3897,14 @@ class TOMWrapper:
 
         if table_name is None:
             raise ValueError(
-                f"{icons.red_dot} The '{measure_name}' is not a valid measure in the '{self._dataset}' semantic model within the '{self._workspace}' workspace."
+                f"{icons.red_dot} The '{measure_name}' is not a valid measure in the '{self._dataset_name}' semantic model within the '{self._workspace_name}' workspace."
             )
 
         table_name = matching_measures[0]
         # Validate date table
         if not self.is_date_table(date_table):
             raise ValueError(
-                f"{icons.red_dot} The '{date_table}' table is not a valid date table in the '{self._dataset}' wemantic model within the '{self._workspace}' workspace."
+                f"{icons.red_dot} The '{date_table}' table is not a valid date table in the '{self._dataset_name}' wemantic model within the '{self._workspace_name}' workspace."
             )
 
         # Extract date key from date table
@@ -3903,7 +3916,7 @@ class TOMWrapper:
 
         if not matching_columns:
             raise ValueError(
-                f"{icons.red_dot} The '{date_table}' table does not have a date key column in the '{self._dataset}' semantic model within the '{self._workspace}' workspace."
+                f"{icons.red_dot} The '{date_table}' table does not have a date key column in the '{self._dataset_name}' semantic model within the '{self._workspace_name}' workspace."
             )
 
         date_key = matching_columns[0]
@@ -4383,7 +4396,6 @@ class TOMWrapper:
         if isinstance(measure_name, str):
             measure_name = [measure_name]
 
-        workspace_id = fabric.resolve_workspace_id(self._workspace)
         client = fabric.FabricRestClient()
 
         if len(measure_name) > max_batch_size:
@@ -4402,7 +4414,7 @@ class TOMWrapper:
                         "modelItems": [],
                     },
                 },
-                "workspaceId": workspace_id,
+                "workspaceId": self._workspace_id,
                 "artifactInfo": {"artifactType": "SemanticModel"},
             }
             for m_name in measure_list:
@@ -4413,7 +4425,7 @@ class TOMWrapper:
                 )
                 if t_name is None:
                     raise ValueError(
-                        f"{icons.red_dot} The '{m_name}' measure does not exist in the '{self._dataset}' semantic model within the '{self._workspace}' workspace."
+                        f"{icons.red_dot} The '{m_name}' measure does not exist in the '{self._dataset_name}' semantic model within the '{self._workspace_name}' workspace."
                     )
 
                 new_item = {
@@ -4515,6 +4527,40 @@ class TOMWrapper:
             TOM.ValueFilterBehaviorType, value_filter_behavior
         )
 
+    def add_role_member(self, role_name: str, member: str | List[str]):
+        """
+        Adds a external model role member (AzureAD) to a role.
+
+        Parameters
+        ----------
+        role_name : str
+            The role name.
+        member : str | List[str]
+            The email address(es) of the member(s) to add.
+        """
+
+        import Microsoft.AnalysisServices.Tabular as TOM
+
+        if isinstance(member, str):
+            member = [member]
+
+        role = self.model.Roles[role_name]
+        current_members = [m.MemberName for m in role.Members]
+
+        for m in member:
+            if m not in current_members:
+                rm = TOM.ExternalModelRoleMember()
+                rm.IdentityProvider = "AzureAD"
+                rm.MemberName = m
+                role.Members.Add(rm)
+                print(
+                    f"{icons.green_dot} '{m}' has been added as a member of the '{role_name}' role."
+                )
+            else:
+                print(
+                    f"{icons.yellow_dot} '{m}' is already a member in the '{role_name}' role."
+                )
+
     def close(self):
 
         if not self._readonly and self.model is not None:
@@ -4572,9 +4618,9 @@ class TOMWrapper:
 
             if len(self._tables_added) > 0:
                 refresh_semantic_model(
-                    dataset=self._dataset,
+                    dataset=self._dataset_id,
                     tables=self._tables_added,
-                    workspace=self._workspace,
+                    workspace=self._workspace_id,
                 )
             self.model = None
 
@@ -4584,15 +4630,15 @@ class TOMWrapper:
 @log
 @contextmanager
 def connect_semantic_model(
-    dataset: str, readonly: bool = True, workspace: Optional[str] = None
+    dataset: str | UUID, readonly: bool = True, workspace: Optional[str] = None
 ) -> Iterator[TOMWrapper]:
     """
     Connects to the Tabular Object Model (TOM) within a semantic model.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | UUID
+        Name or ID of the semantic model.
     readonly: bool, default=True
         Whether the connection is read-only or read/write. Setting this to False enables read/write which saves the changes made back to the server.
     workspace : str, default=None
@@ -4609,10 +4655,6 @@ def connect_semantic_model(
     # initialize .NET to make sure System and Microsoft.AnalysisServices.Tabular is defined
     sempy.fabric._client._utils._init_analysis_services()
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
     tw = TOMWrapper(dataset=dataset, workspace=workspace, readonly=readonly)
     try:
         yield tw