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

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,12 +43,12 @@ def run_model_bpa(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | uuid.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
-        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.
     export : bool, default=False
@@ -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,25 +1,30 @@
 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
 def get_measure_dependencies(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> pd.DataFrame:
     """
     Shows all dependencies for all measures in a semantic model.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -29,8 +34,6 @@ def get_measure_dependencies(
         Shows all dependencies for all measures in the semantic model.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-
     dep = fabric.evaluate_dax(
         dataset=dataset,
         workspace=workspace,
@@ -139,17 +142,18 @@ 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.
-    workspace : str, default=None
-        The Fabric workspace name.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -159,7 +163,6 @@ def get_model_calc_dependencies(
         Shows all dependencies for all objects in the semantic model.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
     dep = fabric.evaluate_dax(
         dataset=dataset,
         workspace=workspace,
@@ -187,12 +190,24 @@ def get_model_calc_dependencies(
         dep["Referenced Table"], dep["Referenced Object"]
     )
     dep["Parent Node"] = dep["Object Name"]
+
     # Initialize dependency DataFrame with 'Done' status
     df = dep.copy()
     objs = {"Measure", "Calc Column", "Calculation Item", "Calc Table"}
     df["Done"] = (
         df["Referenced Object Type"].apply(lambda x: x not in objs).astype(bool)
     )
+
+    # Set to track visited dependencies to prevent circular references
+    visited = set(
+        zip(
+            df["Full Object Name"],
+            df["Referenced Full Object Name"],
+            df["Object Type"],
+            df["Referenced Object Type"],
+        )
+    )
+
     # Expand dependencies iteratively
     while not df["Done"].all():
         incomplete_rows = df[df["Done"] == False]
@@ -206,11 +221,24 @@ def get_model_calc_dependencies(
             # Expand dependencies and update 'Done' status as needed
             new_rows = []
             for _, dependency in dep_filt.iterrows():
+                # Check if the dependency has already been visited
+                dependency_pair = (
+                    row["Full Object Name"],
+                    dependency["Referenced Full Object Name"],
+                    row["Object Type"],
+                    dependency["Referenced Object Type"],
+                )
+                if dependency_pair in visited:
+                    continue  # Skip already visited dependencies
+
+                visited.add(dependency_pair)  # Mark as visited
+
                 is_done = dependency["Referenced Object Type"] not in objs
                 new_row = {
                     "Table Name": row["Table Name"],
                     "Object Name": row["Object Name"],
                     "Object Type": row["Object Type"],
+                    "Expression": row["Expression"],
                     "Referenced Table": dependency["Referenced Table"],
                     "Referenced Object": dependency["Referenced Object"],
                     "Referenced Object Type": dependency["Referenced Object Type"],
@@ -222,7 +250,14 @@ def get_model_calc_dependencies(
                     "Parent Node": row["Referenced Object"],
                 }
                 new_rows.append(new_row)
-            df = pd.concat([df, pd.DataFrame(new_rows)], ignore_index=True)
+
+            if new_rows:
+                new_rows_df = pd.DataFrame(new_rows)
+                new_rows_df = new_rows_df.dropna(
+                    axis=1, how="all"
+                )  # Drop empty columns
+                df = pd.concat([df, new_rows_df], ignore_index=True)
+
             df.loc[df.index == row.name, "Done"] = True
     # Finalize DataFrame and yield result
     df = df.drop(columns=["Done"])
@@ -232,39 +267,36 @@ def get_model_calc_dependencies(
 
 @log
 def measure_dependency_tree(
-    dataset: str, measure_name: str, workspace: Optional[str] = None
+    dataset: str | UUID, measure_name: str, workspace: Optional[str | UUID] = None
 ):
     """
     Prints a measure dependency tree of all dependent objects for a measure in a semantic model.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
     measure_name : str
         Name of the measure.
-    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.
-
-    Returns
-    -------
-
     """
 
-    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)
 
-    dfM = fabric.list_measures(dataset=dataset, workspace=workspace)
+    dfM = fabric.list_measures(dataset=dataset_id, workspace=workspace_id)
     dfM_filt = dfM[dfM["Measure Name"] == measure_name]
 
     if len(dfM_filt) == 0:
         print(
-            f"{icons.red_dot} The '{measure_name}' measure does not exist in the '{dataset}' semantic model in the '{workspace}' workspace."
+            f"{icons.red_dot} The '{measure_name}' measure does not exist in the '{dataset_name}' semantic model in the '{workspace_name}' workspace."
         )
         return
 
-    md = get_measure_dependencies(dataset, workspace)
+    md = get_measure_dependencies(dataset_id, workspace_id)
     df_filt = md[md["Object Name"] == measure_name]
 
     # Create a dictionary to hold references to nodes

sempy_labs/_notebooks.py

@@ -10,10 +10,49 @@ from sempy_labs._helper_functions import (
     _decode_b64,
 )
 from sempy.fabric.exceptions import FabricHTTPException
+import os
+from uuid import UUID
+
+_notebook_prefix = "notebook-content."
+
+
+def _get_notebook_definition_base(
+    notebook_name: str, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    item_id = fabric.resolve_item_id(
+        item_name=notebook_name, type="Notebook", workspace=workspace_id
+    )
+    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 | UUID] = 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(
-    notebook_name: str, workspace: Optional[str] = None, decode: bool = True
+    notebook_name: str, workspace: Optional[str | UUID] = None, decode: bool = True
 ) -> str:
     """
     Obtains the notebook definition.
@@ -24,8 +63,8 @@ def get_notebook_definition(
     ----------
     notebook_name : str
         The name of the notebook.
-    workspace : str, default=None
-        The name of the workspace.
+    workspace : str | uuid.UUID, default=None
+        The name or ID of the workspace.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     decode : bool, default=True
@@ -38,18 +77,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
-    )
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"v1/workspaces/{workspace_id}/notebooks/{item_id}/getDefinition",
+    df_items = _get_notebook_definition_base(
+        notebook_name=notebook_name, workspace=workspace
     )
-
-    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:
@@ -64,7 +95,7 @@ def import_notebook_from_web(
     notebook_name: str,
     url: str,
     description: Optional[str] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     overwrite: bool = False,
 ):
     """
@@ -82,16 +113,15 @@ def import_notebook_from_web(
     description : str, default=None
         The description of the notebook.
         Defaults to None which does not place a description.
-    workspace : str, default=None
-        The name of the workspace.
+    workspace : str | uuid.UUID, default=None
+        The name or ID of the workspace.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     overwrite : bool, default=False
         If set to True, overwrites the existing notebook in the workspace if it exists.
     """
 
-    if workspace is None:
-        workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
     # Fix links to go to the raw github file
     starting_text = "https://github.com/"
@@ -111,24 +141,26 @@ def import_notebook_from_web(
         create_notebook(
             name=notebook_name,
             notebook_content=response.content,
-            workspace=workspace,
+            workspace=workspace_id,
             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."
+            f"{icons.red_dot} The '{notebook_name}' already exists within the '{workspace_name}' workspace and 'overwrite' is set to False."
         )
 
 
 def create_notebook(
     name: str,
     notebook_content: str,
+    type: str = "py",
     description: Optional[str] = None,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
 ):
     """
     Creates a new notebook with a definition within a workspace.
@@ -139,16 +171,18 @@ 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.
-    workspace : str, default=None
-        The name of the workspace.
+    workspace : str | uuid.UUID, default=None
+        The name or ID of the workspace.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     client = fabric.FabricRestClient()
     notebook_payload = base64.b64encode(notebook_content)
 
@@ -158,7 +192,7 @@ def create_notebook(
             "format": "ipynb",
             "parts": [
                 {
-                    "path": "notebook-content.py",
+                    "path": f"{_notebook_prefix}.{type}",
                     "payload": notebook_payload,
                     "payloadType": "InlineBase64",
                 }
@@ -173,12 +207,12 @@ def create_notebook(
     lro(client, response, status_codes=[201, 202])
 
     print(
-        f"{icons.green_dot} The '{name}' notebook was created within the '{workspace}' workspace."
+        f"{icons.green_dot} The '{name}' notebook was created within the '{workspace_name}' workspace."
     )
 
 
 def update_notebook_definition(
-    name: str, notebook_content: str, workspace: Optional[str] = None
+    name: str, notebook_content: str, workspace: Optional[str | UUID] = None
 ):
     """
     Updates an existing notebook with a new definition.
@@ -189,26 +223,26 @@ def update_notebook_definition(
         The name of the notebook to be updated.
     notebook_content : str
         The Jupyter notebook content (not in Base64 format).
-    workspace : str, default=None
-        The name of the workspace.
+    workspace : str | uuid.UUID, default=None
+        The name or ID of the workspace.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     client = fabric.FabricRestClient()
     notebook_payload = base64.b64encode(notebook_content)
     notebook_id = fabric.resolve_item_id(
-        item_name=name, type="Notebook", workspace=workspace
+        item_name=name, type="Notebook", workspace=workspace_id
     )
 
+    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",
                 }
@@ -224,5 +258,5 @@ def update_notebook_definition(
     lro(client, response, return_status_code=True)
 
     print(
-        f"{icons.green_dot} The '{name}' notebook was updated within the '{workspace}' workspace."
+        f"{icons.green_dot} The '{name}' notebook was updated within the '{workspace_name}' workspace."
     )