semantic-link-labs 0.4.1__py3-none-any.whl

sempy_labs/_model_dependencies.py

@@ -0,0 +1,341 @@
+import sempy
+import sempy.fabric as fabric
+import pandas as pd
+from sempy_labs._helper_functions import format_dax_object_name
+from typing import List, Optional, Union
+from anytree import Node, RenderTree
+from sempy._utils._log import log
+
+
+def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
+    """
+    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.
+        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
+        Shows all dependencies for all measures in the semantic model.
+    """
+
+    if workspace == None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+
+    dep = fabric.evaluate_dax(
+        dataset=dataset,
+        workspace=workspace,
+        dax_string="""
+        SELECT 
+         [TABLE] AS [Table Name]
+        ,[OBJECT] AS [Object Name]
+        ,[OBJECT_TYPE] AS [Object Type]
+        ,[REFERENCED_TABLE] AS [Referenced Table]
+        ,[REFERENCED_OBJECT] AS [Referenced Object]
+        ,[REFERENCED_OBJECT_TYPE] AS [Referenced Object Type]
+        FROM $SYSTEM.DISCOVER_CALC_DEPENDENCY
+        WHERE [OBJECT_TYPE] = 'MEASURE'
+        """,
+    )
+
+    dep["Object Type"] = dep["Object Type"].str.capitalize()
+    dep["Referenced Object Type"] = dep["Referenced Object Type"].str.capitalize()
+
+    dep["Full Object Name"] = format_dax_object_name(
+        dep["Table Name"], dep["Object Name"]
+    )
+    dep["Referenced Full Object Name"] = format_dax_object_name(
+        dep["Referenced Table"], dep["Referenced Object"]
+    )
+    dep["Parent Node"] = dep["Object Name"]
+
+    df = dep
+
+    df["Done"] = df.apply(
+        lambda row: False if row["Referenced Object Type"] == "Measure" else True,
+        axis=1,
+    )
+
+    while any(df["Done"] == False):
+        for i, r in df.iterrows():
+            rObjFull = r["Referenced Full Object Name"]
+            rObj = r["Referenced Object"]
+            if r["Done"] == False:
+                dep_filt = dep[dep["Full Object Name"] == rObjFull]
+
+                for index, dependency in dep_filt.iterrows():
+                    d = True
+                    if dependency[5] == "Measure":
+                        d = False
+                        df = pd.concat(
+                            [
+                                df,
+                                pd.DataFrame(
+                                    [
+                                        {
+                                            "Table Name": r["Table Name"],
+                                            "Object Name": r["Object Name"],
+                                            "Object Type": r["Object Type"],
+                                            "Referenced Object": dependency[4],
+                                            "Referenced Table": dependency[3],
+                                            "Referenced Object Type": dependency[5],
+                                            "Done": d,
+                                            "Full Object Name": r["Full Object Name"],
+                                            "Referenced Full Object Name": dependency[
+                                                7
+                                            ],
+                                            "Parent Node": rObj,
+                                        }
+                                    ]
+                                ),
+                            ],
+                            ignore_index=True,
+                        )
+                    else:
+                        df = pd.concat(
+                            [
+                                df,
+                                pd.DataFrame(
+                                    [
+                                        {
+                                            "Table Name": r["Table Name"],
+                                            "Object Name": r["Object Name"],
+                                            "Object Type": r["Object Type"],
+                                            "Referenced Object": dependency[5],
+                                            "Referenced Table": dependency[4],
+                                            "Referenced Object Type": dependency[6],
+                                            "Done": d,
+                                            "Full Object Name": r["Full Object Name"],
+                                            "Referenced Full Object Name": dependency[
+                                                7
+                                            ],
+                                            "Parent Node": rObj,
+                                        }
+                                    ]
+                                ),
+                            ],
+                            ignore_index=True,
+                        )
+
+            df.loc[i, "Done"] = True
+
+    df = df.drop(["Done", "Full Object Name", "Referenced Full Object Name"], axis=1)
+
+    return df
+
+
+def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
+    """
+    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.
+        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
+        Shows all dependencies for all objects in the semantic model.
+    """
+
+    if workspace == None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+
+    dep = fabric.evaluate_dax(
+        dataset=dataset,
+        workspace=workspace,
+        dax_string="""
+        SELECT
+        [TABLE] AS [Table Name]
+        ,[OBJECT] AS [Object Name]
+        ,[OBJECT_TYPE] AS [Object Type]
+        ,[EXPRESSION] AS [Expression]
+        ,[REFERENCED_TABLE] AS [Referenced Table]
+        ,[REFERENCED_OBJECT] AS [Referenced Object]
+        ,[REFERENCED_OBJECT_TYPE] AS [Referenced Object Type]
+        FROM $SYSTEM.DISCOVER_CALC_DEPENDENCY        
+        """,
+    )
+
+    dep["Object Type"] = dep["Object Type"].str.replace("_", " ").str.title()
+    dep["Referenced Object Type"] = (
+        dep["Referenced Object Type"].str.replace("_", " ").str.title()
+    )
+
+    dep["Full Object Name"] = format_dax_object_name(
+        dep["Table Name"], dep["Object Name"]
+    )
+    dep["Referenced Full Object Name"] = format_dax_object_name(
+        dep["Referenced Table"], dep["Referenced Object"]
+    )
+    dep["Parent Node"] = dep["Object Name"]
+
+    df = dep
+
+    objs = ["Measure", "Calc Column", "Calculation Item", "Calc Table"]
+
+    df["Done"] = df.apply(
+        lambda row: False if row["Referenced Object Type"] in objs else True, axis=1
+    )
+
+    while any(df["Done"] == False):
+        for i, r in df.iterrows():
+            rObjFull = r["Referenced Full Object Name"]
+            rObj = r["Referenced Object"]
+            if r["Done"] == False:
+                dep_filt = dep[dep["Full Object Name"] == rObjFull]
+
+                for index, dependency in dep_filt.iterrows():
+                    d = True
+                    if dependency[5] in objs:
+                        d = False
+                        df = pd.concat(
+                            [
+                                df,
+                                pd.DataFrame(
+                                    [
+                                        {
+                                            "Table Name": r["Table Name"],
+                                            "Object Name": r["Object Name"],
+                                            "Object Type": r["Object Type"],
+                                            "Referenced Object": dependency[4],
+                                            "Referenced Table": dependency[3],
+                                            "Referenced Object Type": dependency[5],
+                                            "Done": d,
+                                            "Full Object Name": r["Full Object Name"],
+                                            "Referenced Full Object Name": dependency[
+                                                7
+                                            ],
+                                            "Parent Node": rObj,
+                                        }
+                                    ]
+                                ),
+                            ],
+                            ignore_index=True,
+                        )
+                    else:
+                        df = pd.concat(
+                            [
+                                df,
+                                pd.DataFrame(
+                                    [
+                                        {
+                                            "Table Name": r["Table Name"],
+                                            "Object Name": r["Object Name"],
+                                            "Object Type": r["Object Type"],
+                                            "Referenced Object": dependency[5],
+                                            "Referenced Table": dependency[4],
+                                            "Referenced Object Type": dependency[6],
+                                            "Done": d,
+                                            "Full Object Name": r["Full Object Name"],
+                                            "Referenced Full Object Name": dependency[
+                                                7
+                                            ],
+                                            "Parent Node": rObj,
+                                        }
+                                    ]
+                                ),
+                            ],
+                            ignore_index=True,
+                        )
+
+            df.loc[i, "Done"] = True
+
+    df = df.drop(["Done"], axis=1)
+
+    return df
+
+
+@log
+def measure_dependency_tree(
+    dataset: str, measure_name: str, workspace: Optional[str] = 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.
+    measure_name : str
+        Name of the measure.
+    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
+    -------
+
+    """
+
+    if workspace == None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+
+    dfM = fabric.list_measures(dataset=dataset, workspace=workspace)
+    dfM_filt = dfM[dfM["Measure Name"] == measure_name]
+
+    if len(dfM_filt) == 0:
+        print(
+            f"The '{measure_name}' measure does not exist in the '{dataset}' semantic model in the '{workspace}' workspace."
+        )
+        return
+
+    md = get_measure_dependencies(dataset, workspace)
+    df_filt = md[md["Object Name"] == measure_name]
+
+    # Create a dictionary to hold references to nodes
+    node_dict = {}
+    measureIcon = "\u2211"
+    tableIcon = "\u229E"
+    columnIcon = "\u229F"
+
+    # Populate the tree
+    for _, row in df_filt.iterrows():
+        # measure_name = row['Object Name']
+        ref_obj_table_name = row["Referenced Table"]
+        ref_obj_name = row["Referenced Object"]
+        ref_obj_type = row["Referenced Object Type"]
+        parent_node_name = row["Parent Node"]
+
+        # Create or get the parent node
+        parent_node = node_dict.get(parent_node_name)
+        if parent_node is None:
+            parent_node = Node(parent_node_name)
+            node_dict[parent_node_name] = parent_node
+        parent_node.custom_property = measureIcon + " "
+
+        # Create the child node
+        child_node_name = ref_obj_name
+        child_node = Node(child_node_name, parent=parent_node)
+        if ref_obj_type == "Column":
+            child_node.custom_property = columnIcon + " '" + ref_obj_table_name + "'"
+        elif ref_obj_type == "Table":
+            child_node.custom_property = tableIcon + " "
+        elif ref_obj_type == "Measure":
+            child_node.custom_property = measureIcon + " "
+
+        # Update the dictionary with the child node
+        node_dict[child_node_name] = child_node
+
+    # Visualize the tree structure using RenderTree
+    for pre, _, node in RenderTree(node_dict[measure_name]):
+        if tableIcon in node.custom_property:
+            print(f"{pre}{node.custom_property}'{node.name}'")
+        else:
+            print(f"{pre}{node.custom_property}[{node.name}]")

sempy_labs/_one_lake_integration.py

@@ -0,0 +1,155 @@
+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
+
+
+@log
+def export_model_to_onelake(
+    dataset: str,
+    workspace: Optional[str] = None,
+    destination_lakehouse: Optional[str] = None,
+    destination_workspace: Optional[str] = None,
+):
+    """
+    Exports a semantic model's tables to delta tables in the lakehouse. Creates shortcuts to the tables if a lakehouse is specified.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    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.
+    destination_lakehouse : str, default=None
+        The name of the Fabric lakehouse where shortcuts will be created to access the delta tables created by the export. If the lakehouse specified does not exist, one will be created with that name. If no lakehouse is specified, shortcuts will not be created.
+    destination_workspace : str, default=None
+        The name of the Fabric workspace in which the lakehouse resides.
+    """
+
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    if destination_workspace == None:
+        destination_workspace = workspace
+        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:
+        print(
+            f"The '{dataset}' semantic model does not exist in the '{workspace}' workspace."
+        )
+        return
+
+    tmsl = f"""
+    {{
+    'export': {{
+    'layout': 'delta',
+    'type': 'full',  
+    'objects': [  
+        {{  
+        'database': '{dataset}'
+        }}  
+    ]  
+    }}  
+    }}
+    """
+
+    # Export model's tables as delta tables
+    try:
+        fabric.execute_tmsl(script=tmsl, workspace=workspace)
+        print(
+            f"The '{dataset}' semantic model's tables have been exported as delta tables to the '{workspace}' workspace.\n"
+        )
+    except:
+        print(
+            f"ERROR: The '{dataset}' semantic model's tables have not been exported as delta tables to the '{workspace}' workspace."
+        )
+        print(
+            f"Make 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"
+        )
+        return
+
+    # Create shortcuts if destination lakehouse is specified
+    if destination_lakehouse is not None:
+        # Destination...
+        dfI_Dest = fabric.list_items(workspace=destination_workspace, type="Lakehouse")
+        dfI_filt = dfI_Dest[(dfI_Dest["Display Name"] == destination_lakehouse)]
+
+        if len(dfI_filt) == 0:
+            print(
+                f"The '{destination_lakehouse}' lakehouse does not exist within the '{destination_workspace}' workspace."
+            )
+            # Create lakehouse
+            destination_lakehouse_id = fabric.create_lakehouse(
+                display_name=destination_lakehouse, workspace=destination_workspace
+            )
+            print(
+                f"The '{destination_lakehouse}' lakehouse has been created within the '{destination_workspace}' workspace.\n"
+            )
+        else:
+            destination_lakehouse_id = dfI_filt["Id"].iloc[0]
+
+        # Source...
+        dfI_Source = fabric.list_items(workspace=workspace, 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,
+            additional_xmla_properties=["Parent.SystemManaged"],
+        )
+        dfP_filt = dfP[
+            (dfP["Mode"] == "Import")
+            & (dfP["Source Type"] != "CalculationGroup")
+            & (dfP["Parent System Managed"] == False)
+        ]
+        dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
+        tmc = pd.DataFrame(dfP.groupby("Table Name")["Mode"].nunique()).reset_index()
+        oneMode = tmc[tmc["Mode"] == 1]
+        tableAll = dfP_filt[
+            dfP_filt["Table Name"].isin(dfC["Table Name"].values)
+            & (dfP_filt["Table Name"].isin(oneMode["Table Name"].values))
+        ]
+        tables = tableAll["Table Name"].unique()
+
+        client = fabric.FabricRestClient()
+
+        print("Creating shortcuts...\n")
+        for tableName in tables:
+            tablePath = "Tables/" + tableName
+            shortcutName = tableName.replace(" ", "")
+            request_body = {
+                "path": "Tables",
+                "name": shortcutName,
+                "target": {
+                    "oneLake": {
+                        "workspaceId": workspace_id,
+                        "itemId": sourceLakehouseId,
+                        "path": tablePath,
+                    }
+                },
+            }
+
+            try:
+                response = client.post(
+                    f"/v1/workspaces/{destination_workspace_id}/items/{destination_lakehouse_id}/shortcuts",
+                    json=request_body,
+                )
+                if response.status_code == 201:
+                    print(
+                        f"\u2022 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"
+                    )
+                else:
+                    print(response.status_code)
+            except:
+                print(
+                    f"ERROR: Failed to create a shortcut for the '{tableName}' table."
+                )