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

sempy_labs/_list_functions.py

@@ -7,23 +7,25 @@ from sempy_labs._helper_functions import (
     pagination,
     resolve_item_type,
     format_dax_object_name,
+    resolve_dataset_name_and_id,
 )
 import pandas as pd
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
+from uuid import UUID
 
 
 def get_object_level_security(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str] = None
 ) -> pd.DataFrame:
     """
     Shows the object level security for the semantic model.
 
     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
@@ -37,12 +39,13 @@ def get_object_level_security(
 
     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_id)
 
     df = pd.DataFrame(columns=["Role Name", "Object Type", "Table Name", "Object Name"])
 
     with connect_semantic_model(
-        dataset=dataset, readonly=True, workspace=workspace
+        dataset=dataset_id, readonly=True, workspace=workspace_id
     ) as tom:
 
         for r in tom.model.Roles:
@@ -82,15 +85,15 @@ def get_object_level_security(
 
 
 def list_tables(
-    dataset: str, workspace: Optional[str] = None, extended: bool = False
+    dataset: str | UUID, workspace: Optional[str] = None, extended: bool = False
 ) -> pd.DataFrame:
     """
     Shows a semantic model's tables and their properties.
 
     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
@@ -106,7 +109,8 @@ def list_tables(
 
     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_id)
 
     df = pd.DataFrame(
         columns=[
@@ -121,20 +125,20 @@ def list_tables(
     )
 
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=True
+        dataset=dataset_id, workspace=workspace_id, readonly=True
     ) as tom:
         if extended:
             dict_df = fabric.evaluate_dax(
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
                 dax_string="""
                 EVALUATE SELECTCOLUMNS(FILTER(INFO.STORAGETABLECOLUMNS(), [COLUMN_TYPE] = "BASIC_DATA"),[DIMENSION_NAME],[DICTIONARY_SIZE])
                 """,
             )
             dict_sum = dict_df.groupby("[DIMENSION_NAME]")["[DICTIONARY_SIZE]"].sum()
             data = fabric.evaluate_dax(
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
                 dax_string="""EVALUATE SELECTCOLUMNS(INFO.STORAGETABLECOLUMNSEGMENTS(),[TABLE_ID],[DIMENSION_NAME],[USED_SIZE])""",
             )
             data_sum = (
@@ -162,8 +166,8 @@ def list_tables(
                 .sum()
             )
             rc = fabric.evaluate_dax(
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
                 dax_string="""
                 SELECT [DIMENSION_NAME],[ROWS_COUNT] FROM $SYSTEM.DISCOVER_STORAGE_TABLES
                 WHERE RIGHT ( LEFT ( TABLE_ID, 2 ), 1 ) <> '$'
@@ -616,11 +620,7 @@ def list_dashboards(workspace: Optional[str] = None) -> pd.DataFrame:
         ]
     )
 
-    if workspace == "None":
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resovle_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
     client = fabric.PowerBIRestClient()
     response = client.get(f"/v1.0/myorg/groups/{workspace_id}/dashboards")
@@ -635,8 +635,8 @@ def list_dashboards(workspace: Optional[str] = None) -> pd.DataFrame:
             "Web URL": v.get("webUrl"),
             "Embed URL": v.get("embedUrl"),
             "Data Classification": v.get("dataClassification"),
-            "Users": [v.get("users")],
-            "Subscriptions": [v.get("subscriptions")],
+            "Users": v.get("users"),
+            "Subscriptions": v.get("subscriptions"),
         }
         df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
@@ -854,15 +854,15 @@ def update_item(
 
 
 def list_relationships(
-    dataset: str, workspace: Optional[str] = None, extended: bool = False
+    dataset: str | UUID, workspace: Optional[str] = None, extended: bool = False
 ) -> pd.DataFrame:
     """
     Shows a semantic model's relationships and their properties.
 
     Parameters
     ----------
-    dataset: str
-        Name of the semantic model.
+    dataset: str | UUID
+        Name or UUID of the semantic model.
     workspace : str, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -876,17 +876,18 @@ def list_relationships(
         A pandas dataframe showing the object level security for the 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_id)
 
-    dfR = fabric.list_relationships(dataset=dataset, workspace=workspace)
+    dfR = fabric.list_relationships(dataset=dataset_id, workspace=workspace_id)
     dfR["From Object"] = format_dax_object_name(dfR["From Table"], dfR["From Column"])
     dfR["To Object"] = format_dax_object_name(dfR["To Table"], dfR["To Column"])
 
     if extended:
         # Used to map the Relationship IDs
         rel = fabric.evaluate_dax(
-            dataset=dataset,
-            workspace=workspace,
+            dataset=dataset_id,
+            workspace=workspace_id,
             dax_string="""
                 SELECT
                 [ID] AS [RelationshipID]
@@ -897,8 +898,8 @@ def list_relationships(
 
         # USED_SIZE shows the Relationship Size where TABLE_ID starts with R$
         cs = fabric.evaluate_dax(
-            dataset=dataset,
-            workspace=workspace,
+            dataset=dataset_id,
+            workspace=workspace_id,
             dax_string="""
                 SELECT
                 [TABLE_ID]
@@ -1574,3 +1575,148 @@ def list_semantic_model_object_report_usage(
     final_df.reset_index(drop=True, inplace=True)
 
     return final_df
+
+
+def list_server_properties(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Lists the `properties <https://learn.microsoft.com/dotnet/api/microsoft.analysisservices.serverproperty?view=analysisservices-dotnet>`_ of the Analysis Services instance.
+
+    Parameters
+    ----------
+    workspace : str, 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.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of the server properties.
+    """
+
+    tom_server = fabric.create_tom_server(readonly=True, workspace=workspace)
+
+    rows = [
+        {
+            "Name": sp.Name,
+            "Value": sp.Value,
+            "Default Value": sp.DefaultValue,
+            "Is Read Only": sp.IsReadOnly,
+            "Requires Restart": sp.RequiresRestart,
+            "Units": sp.Units,
+            "Category": sp.Category,
+        }
+        for sp in tom_server.ServerProperties
+    ]
+
+    tom_server.Dispose()
+    df = pd.DataFrame(rows)
+
+    bool_cols = ["Is Read Only", "Requires Restart"]
+    df[bool_cols] = df[bool_cols].astype(bool)
+
+    return df
+
+
+def list_semantic_model_errors(
+    dataset: str | UUID, workspace: Optional[str | UUID]
+) -> pd.DataFrame:
+    """
+    Shows a list of a semantic model's errors and their error messages (if they exist).
+
+    Parameters
+    ----------
+    dataset : str | UUID
+        Name or ID of the semantic model.
+    workspace : str | 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
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of the errors and error messages for a given semantic model.
+    """
+
+    from sempy_labs.tom import connect_semantic_model
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(
+        dataset, workspace=workspace_id
+    )
+
+    error_rows = []
+
+    with connect_semantic_model(
+        dataset=dataset_id, workspace=workspace_id, readonly=True
+    ) as tom:
+        # Define mappings of TOM objects to object types and attributes
+        error_checks = [
+            ("Column", tom.all_columns, lambda o: o.ErrorMessage),
+            ("Partition", tom.all_partitions, lambda o: o.ErrorMessage),
+            (
+                "Partition - Data Coverage Expression",
+                tom.all_partitions,
+                lambda o: (
+                    o.DataCoverageDefinition.ErrorMessage
+                    if o.DataCoverageDefinition
+                    else ""
+                ),
+            ),
+            ("Row Level Security", tom.all_rls, lambda o: o.ErrorMessage),
+            ("Calculation Item", tom.all_calculation_items, lambda o: o.ErrorMessage),
+            ("Measure", tom.all_measures, lambda o: o.ErrorMessage),
+            (
+                "Measure - Detail Rows Expression",
+                tom.all_measures,
+                lambda o: (
+                    o.DetailRowsDefinition.ErrorMessage
+                    if o.DetailRowsDefinition
+                    else ""
+                ),
+            ),
+            (
+                "Measure - Format String Expression",
+                tom.all_measures,
+                lambda o: (
+                    o.FormatStringDefinition.ErrorMessage
+                    if o.FormatStringDefinition
+                    else ""
+                ),
+            ),
+            (
+                "Calculation Group - Multiple or Empty Selection Expression",
+                tom.all_calculation_groups,
+                lambda o: (
+                    o.CalculationGroup.MultipleOrEmptySelectionExpression.ErrorMessage
+                    if o.CalculationGroup.MultipleOrEmptySelectionExpression
+                    else ""
+                ),
+            ),
+            (
+                "Calculation Group - No Selection Expression",
+                tom.all_calculation_groups,
+                lambda o: (
+                    o.CalculationGroup.NoSelectionExpression.ErrorMessage
+                    if o.CalculationGroup.NoSelectionExpression
+                    else ""
+                ),
+            ),
+        ]
+
+        # Iterate over all error checks
+        for object_type, getter, error_extractor in error_checks:
+            for obj in getter():
+                error_message = error_extractor(obj)
+                if error_message:  # Only add rows if there's an error message
+                    error_rows.append(
+                        {
+                            "Object Type": object_type,
+                            "Table Name": obj.Parent.Name,
+                            "Object Name": obj.Name,
+                            "Error Message": error_message,
+                        }
+                    )
+
+    return pd.DataFrame(error_rows)

sempy_labs/_model_bpa.py

@@ -10,9 +10,10 @@ from sempy_labs._helper_functions import (
     create_relationship_name,
     save_as_delta_table,
     resolve_workspace_capacity,
-    resolve_dataset_id,
+    resolve_dataset_name_and_id,
     get_language_codes,
     _get_max_run_id,
+    resolve_workspace_name_and_id,
 )
 from sempy_labs.lakehouse import get_lakehouse_tables, lakehouse_attached
 from sempy_labs.tom import connect_semantic_model
@@ -23,11 +24,12 @@ import sempy_labs._icons as icons
 from pyspark.sql.functions import col, flatten
 from pyspark.sql.types import StructType, StructField, StringType
 import os
+from uuid import UUID
 
 
 @log
 def run_model_bpa(
-    dataset: str,
+    dataset: str | UUID,
     rules: Optional[pd.DataFrame] = None,
     workspace: Optional[str] = None,
     export: bool = False,
@@ -41,8 +43,8 @@ def run_model_bpa(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | UUID
+        Name or ID of the semantic model.
     rules : pandas.DataFrame, default=None
         A pandas dataframe containing rules to be evaluated.
     workspace : str, default=None
@@ -105,28 +107,27 @@ def run_model_bpa(
         if language is not None:
             language = map_language(language, language_list)
 
-    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
+    )
 
     if language is not None and language not in language_list:
         print(
             f"{icons.yellow_dot} The '{language}' language code is not in our predefined language list. Please file an issue and let us know which language code you are using: https://github.com/microsoft/semantic-link-labs/issues/new?assignees=&labels=&projects=&template=bug_report.md&title=."
         )
 
-    if extended:
-        icons.sll_tags.append("ModelBPAExtended")
-        with connect_semantic_model(
-            dataset=dataset, workspace=workspace, readonly=False
-        ) as tom:
-            tom.set_vertipaq_annotations()
-
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=True
+        dataset=dataset_id, workspace=workspace_id, readonly=True
     ) as tom:
 
+        if extended:
+            tom.set_vertipaq_annotations()
+
         # Do not run BPA for models with no tables
         if tom.model.Tables.Count == 0:
             print(
-                f"{icons.warning} The '{dataset}' semantic model within the '{workspace}' workspace has no tables and therefore there are no valid BPA results."
+                f"{icons.warning} The '{dataset_name}' semantic model within the '{workspace_name}' workspace has no tables and therefore there are no valid BPA results."
             )
             finalDF = pd.DataFrame(
                 columns=[
@@ -140,7 +141,9 @@ def run_model_bpa(
                 ]
             )
         else:
-            dep = get_model_calc_dependencies(dataset=dataset, workspace=workspace)
+            dep = get_model_calc_dependencies(
+                dataset=dataset_id, workspace=workspace_id
+            )
 
             def translate_using_po(rule_file):
                 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -386,20 +389,19 @@ def run_model_bpa(
             runId = max_run_id + 1
 
         now = datetime.datetime.now()
-        dfD = fabric.list_datasets(workspace=workspace, mode="rest")
-        dfD_filt = dfD[dfD["Dataset Name"] == dataset]
+        dfD = fabric.list_datasets(workspace=workspace_id, mode="rest")
+        dfD_filt = dfD[dfD["Dataset Id"] == dataset_id]
         configured_by = dfD_filt["Configured By"].iloc[0]
-        capacity_id, capacity_name = resolve_workspace_capacity(workspace=workspace)
+        capacity_id, capacity_name = resolve_workspace_capacity(workspace=workspace_id)
         dfExport["Capacity Name"] = capacity_name
         dfExport["Capacity Id"] = capacity_id
-        dfExport["Workspace Name"] = workspace
-        dfExport["Workspace Id"] = fabric.resolve_workspace_id(workspace)
-        dfExport["Dataset Name"] = dataset
-        dfExport["Dataset Id"] = resolve_dataset_id(dataset, workspace)
+        dfExport["Workspace Name"] = workspace_name
+        dfExport["Workspace Id"] = workspace_id
+        dfExport["Dataset Name"] = dataset_name
+        dfExport["Dataset Id"] = dataset_id
         dfExport["Configured By"] = configured_by
         dfExport["Timestamp"] = now
         dfExport["RunId"] = runId
-        dfExport["Configured By"] = configured_by
         dfExport["RunId"] = dfExport["RunId"].astype("int")
 
         dfExport = dfExport[list(icons.bpa_schema.keys())]

sempy_labs/_model_bpa_bulk.py

@@ -119,16 +119,16 @@ def run_model_bpa_bulk(
             dfD_filt = dfD[~dfD["Dataset Name"].isin(skip_models)]
 
             if len(dfD_filt) > 0:
-                for i2, r2 in dfD_filt.iterrows():
+                for _, r2 in dfD_filt.iterrows():
+                    dataset_id = r2["Dataset Id"]
                     dataset_name = r2["Dataset Name"]
                     config_by = r2["Configured By"]
-                    dataset_id = r2["Dataset Id"]
                     print(
                         f"{icons.in_progress} Collecting Model BPA stats for the '{dataset_name}' semantic model within the '{wksp}' workspace."
                     )
                     try:
                         bpa_df = run_model_bpa(
-                            dataset=dataset_name,
+                            dataset=dataset_id,
                             workspace=wksp,
                             language=language,
                             return_dataframe=True,

sempy_labs/_model_dependencies.py

@@ -1,10 +1,15 @@
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs._helper_functions import format_dax_object_name
+from sempy_labs._helper_functions import (
+    format_dax_object_name,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
+)
 import sempy_labs._icons as icons
 from typing import Any, Dict, Optional
 from anytree import Node, RenderTree
 from sempy._utils._log import log
+from uuid import UUID
 
 
 @log
@@ -139,15 +144,15 @@ def get_measure_dependencies(
 
 @log
 def get_model_calc_dependencies(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str] = None
 ) -> pd.DataFrame:
     """
     Shows all dependencies for all objects in a semantic model.
 
     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
@@ -159,10 +164,11 @@ def get_model_calc_dependencies(
         Shows all dependencies for all objects in the 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_id)
     dep = fabric.evaluate_dax(
-        dataset=dataset,
-        workspace=workspace,
+        dataset=dataset_id,
+        workspace=workspace_id,
         dax_string="""
         SELECT
             [TABLE] AS [Table Name],

sempy_labs/_notebooks.py

@@ -10,6 +10,42 @@ from sempy_labs._helper_functions import (
     _decode_b64,
 )
 from sempy.fabric.exceptions import FabricHTTPException
+import os
+
+_notebook_prefix = "notebook-content."
+
+
+def _get_notebook_definition_base(
+    notebook_name: str, workspace: Optional[str] = None
+) -> pd.DataFrame:
+
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    item_id = fabric.resolve_item_id(
+        item_name=notebook_name, type="Notebook", workspace=workspace
+    )
+    client = fabric.FabricRestClient()
+    response = client.post(
+        f"v1/workspaces/{workspace_id}/notebooks/{item_id}/getDefinition",
+    )
+
+    result = lro(client, response).json()
+
+    return pd.json_normalize(result["definition"]["parts"])
+
+
+def _get_notebook_type(notebook_name: str, workspace: Optional[str] = None) -> str:
+
+    df_items = _get_notebook_definition_base(
+        notebook_name=notebook_name, workspace=workspace
+    )
+
+    file_path = df_items[df_items["path"].str.startswith(_notebook_prefix)][
+        "path"
+    ].iloc[0]
+
+    _, file_extension = os.path.splitext(file_path)
+
+    return file_extension[1:]
 
 
 def get_notebook_definition(
@@ -38,18 +74,10 @@ def get_notebook_definition(
         The notebook definition.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-    item_id = fabric.resolve_item_id(
-        item_name=notebook_name, type="Notebook", workspace=workspace
+    df_items = _get_notebook_definition_base(
+        notebook_name=notebook_name, workspace=workspace
     )
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"v1/workspaces/{workspace_id}/notebooks/{item_id}/getDefinition",
-    )
-
-    result = lro(client, response).json()
-    df_items = pd.json_normalize(result["definition"]["parts"])
-    df_items_filt = df_items[df_items["path"] == "notebook-content.py"]
+    df_items_filt = df_items[df_items["path"].str.startswith(_notebook_prefix)]
     payload = df_items_filt["payload"].iloc[0]
 
     if decode:
@@ -115,9 +143,10 @@ def import_notebook_from_web(
             description=description,
         )
     elif len(dfI_filt) > 0 and overwrite:
-        update_notebook_definition(
-            name=notebook_name, notebook_content=response.content, workspace=workspace
-        )
+        print(f"{icons.info} Overwrite of notebooks is currently not supported.")
+        # update_notebook_definition(
+        #    name=notebook_name, notebook_content=response.content, workspace=workspace
+        # )
     else:
         raise ValueError(
             f"{icons.red_dot} The '{notebook_name}' already exists within the '{workspace}' workspace and 'overwrite' is set to False."
@@ -127,6 +156,7 @@ def import_notebook_from_web(
 def create_notebook(
     name: str,
     notebook_content: str,
+    type: str = "py",
     description: Optional[str] = None,
     workspace: Optional[str] = None,
 ):
@@ -139,6 +169,8 @@ def create_notebook(
         The name of the notebook to be created.
     notebook_content : str
         The Jupyter notebook content (not in Base64 format).
+    type : str, default="py"
+        The notebook type.
     description : str, default=None
         The description of the notebook.
         Defaults to None which does not place a description.
@@ -158,7 +190,7 @@ def create_notebook(
             "format": "ipynb",
             "parts": [
                 {
-                    "path": "notebook-content.py",
+                    "path": f"{_notebook_prefix}.{type}",
                     "payload": notebook_payload,
                     "payloadType": "InlineBase64",
                 }
@@ -202,13 +234,13 @@ def update_notebook_definition(
         item_name=name, type="Notebook", workspace=workspace
     )
 
+    type = _get_notebook_type(notebook_name=name, workspace=workspace_id)
+
     request_body = {
-        "displayName": name,
         "definition": {
-            "format": "ipynb",
             "parts": [
                 {
-                    "path": "notebook-content.py",
+                    "path": f"{_notebook_prefix}.{type}",
                     "payload": notebook_payload,
                     "payloadType": "InlineBase64",
                 }