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

sempy_labs/_model_dependencies.py

@@ -14,17 +14,17 @@ 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.
 
@@ -34,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,
@@ -144,17 +142,18 @@ def get_measure_dependencies(
 
 @log
 def get_model_calc_dependencies(
-    dataset: str | UUID, 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 | UUID
+    dataset : str | uuid.UUID
         Name or ID 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.
 
@@ -164,11 +163,9 @@ def get_model_calc_dependencies(
         Shows all dependencies for all objects in the semantic model.
     """
 
-    (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_id,
-        workspace=workspace_id,
+        dataset=dataset,
+        workspace=workspace,
         dax_string="""
         SELECT
             [TABLE] AS [Table Name],
@@ -193,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]
@@ -212,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"],
@@ -228,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"])
@@ -238,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

@@ -11,17 +11,18 @@ from sempy_labs._helper_functions import (
 )
 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] = None
+    notebook_name: str, workspace: Optional[str | UUID] = None
 ) -> pd.DataFrame:
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     item_id = fabric.resolve_item_id(
-        item_name=notebook_name, type="Notebook", workspace=workspace
+        item_name=notebook_name, type="Notebook", workspace=workspace_id
     )
     client = fabric.FabricRestClient()
     response = client.post(
@@ -33,7 +34,9 @@ def _get_notebook_definition_base(
     return pd.json_normalize(result["definition"]["parts"])
 
 
-def _get_notebook_type(notebook_name: str, workspace: Optional[str] = None) -> str:
+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
@@ -49,7 +52,7 @@ def _get_notebook_type(notebook_name: str, workspace: Optional[str] = None) -> s
 
 
 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.
@@ -60,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
@@ -92,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,
 ):
     """
@@ -110,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/"
@@ -139,7 +141,7 @@ 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:
@@ -149,7 +151,7 @@ def import_notebook_from_web(
         # )
     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."
         )
 
 
@@ -158,7 +160,7 @@ def create_notebook(
     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.
@@ -174,13 +176,13 @@ def create_notebook(
     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)
 
@@ -205,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.
@@ -221,17 +223,17 @@ 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)
@@ -256,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."
     )

sempy_labs/_one_lake_integration.py

@@ -2,14 +2,18 @@ import sempy.fabric as fabric
 import pandas as pd
 from typing import Optional
 from sempy._utils._log import log
-from sempy_labs._helper_functions import resolve_workspace_name_and_id
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+)
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 @log
 def export_model_to_onelake(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     destination_lakehouse: Optional[str] = None,
     destination_workspace: Optional[str] = None,
 ):
@@ -18,10 +22,10 @@ def export_model_to_onelake(
 
     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.
     destination_lakehouse : str, default=None
@@ -30,22 +34,15 @@ def export_model_to_onelake(
         The name of the Fabric workspace in which the lakehouse resides.
     """
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     if destination_workspace is None:
-        destination_workspace = workspace
+        destination_workspace = workspace_name
         destination_workspace_id = workspace_id
     else:
         destination_workspace_id = fabric.resolve_workspace_id(destination_workspace)
 
-    dfD = fabric.list_datasets(workspace=workspace)
-    dfD_filt = dfD[dfD["Dataset Name"] == dataset]
-
-    if len(dfD_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model does not exist in the '{workspace}' workspace."
-        )
-
     tmsl = f"""
     {{
     'export': {{
@@ -53,7 +50,7 @@ def export_model_to_onelake(
     'type': 'full',
     'objects': [
         {{
-        'database': '{dataset}'
+        'database': '{dataset_name}'
         }}
     ]
     }}
@@ -62,13 +59,13 @@ def export_model_to_onelake(
 
     # Export model's tables as delta tables
     try:
-        fabric.execute_tmsl(script=tmsl, workspace=workspace)
+        fabric.execute_tmsl(script=tmsl, workspace=workspace_id)
         print(
-            f"{icons.green_dot} The '{dataset}' semantic model's tables have been exported as delta tables to the '{workspace}' workspace.\n"
+            f"{icons.green_dot} The '{dataset_name}' semantic model's tables have been exported as delta tables to the '{workspace_name}' workspace.\n"
         )
     except Exception as e:
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model's tables have not been exported as delta tables to the '{workspace}' workspace.\nMake sure you enable OneLake integration for the '{dataset}' semantic model. Follow the instructions here: https://learn.microsoft.com/power-bi/enterprise/onelake-integration-overview#enable-onelake-integration"
+            f"{icons.red_dot} The '{dataset_name}' semantic model's tables have not been exported as delta tables to the '{workspace_name}' workspace.\nMake sure you enable OneLake integration for the '{dataset_name}' semantic model. Follow the instructions here: https://learn.microsoft.com/power-bi/enterprise/onelake-integration-overview#enable-onelake-integration"
         ) from e
 
     # Create shortcuts if destination lakehouse is specified
@@ -92,14 +89,14 @@ def export_model_to_onelake(
             destination_lakehouse_id = dfI_filt["Id"].iloc[0]
 
         # Source...
-        dfI_Source = fabric.list_items(workspace=workspace, type="SemanticModel")
+        dfI_Source = fabric.list_items(workspace=workspace_id, type="SemanticModel")
         dfI_filtSource = dfI_Source[(dfI_Source["Display Name"] == dataset)]
         sourceLakehouseId = dfI_filtSource["Id"].iloc[0]
 
         # Valid tables
         dfP = fabric.list_partitions(
-            dataset=dataset,
-            workspace=workspace,
+            dataset=dataset_id,
+            workspace=workspace_id,
             additional_xmla_properties=["Parent.SystemManaged"],
         )
         dfP_filt = dfP[
@@ -107,7 +104,7 @@ def export_model_to_onelake(
             & (dfP["Source Type"] != "CalculationGroup")
             & (dfP["Parent System Managed"] == False)
         ]
-        dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
+        dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id)
         tmc = pd.DataFrame(dfP.groupby("Table Name")["Mode"].nunique()).reset_index()
         oneMode = tmc[tmc["Mode"] == 1]
         tableAll = dfP_filt[
@@ -141,7 +138,7 @@ def export_model_to_onelake(
                 )
                 if response.status_code == 201:
                     print(
-                        f"{icons.bullet} The shortcut '{shortcutName}' was created in the '{destination_lakehouse}' lakehouse within the '{destination_workspace}' workspace. It is based on the '{tableName}' table in the '{dataset}' semantic model within the '{workspace}' workspace.\n"
+                        f"{icons.bullet} The shortcut '{shortcutName}' was created in the '{destination_lakehouse}' lakehouse within the '{destination_workspace}' workspace. It is based on the '{tableName}' table in the '{dataset_name}' semantic model within the '{workspace_name}' workspace.\n"
                     )
                 else:
                     print(response.status_code)