semantic-link-labs 0.7.3__py3-none-any.whl → 0.8.0__py3-none-any.whl

sempy_labs/_list_functions.py

@@ -4,15 +4,13 @@ from sempy_labs._helper_functions import (
     create_relationship_name,
     resolve_lakehouse_id,
     resolve_dataset_id,
-    _decode_b64,
     pagination,
     lro,
     resolve_item_type,
+    format_dax_object_name,
+    pagination,
 )
 import pandas as pd
-import base64
-import requests
-from pyspark.sql import SparkSession
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
@@ -169,10 +167,19 @@ def list_tables(
                 dataset=dataset,
                 workspace=workspace,
                 dax_string="""
-                SELECT [DIMENSION_NAME],[DIMENSION_CARDINALITY] FROM $SYSTEM.MDSCHEMA_DIMENSIONS
+                SELECT [DIMENSION_NAME],[ROWS_COUNT] FROM $SYSTEM.DISCOVER_STORAGE_TABLES
+                WHERE RIGHT ( LEFT ( TABLE_ID, 2 ), 1 ) <> '$'
             """,
             )
 
+            model_size = (
+                dict_sum.sum()
+                + data_sum.sum()
+                + hier_sum.sum()
+                + rel_sum.sum()
+                + uh_sum.sum()
+            )
+
         rows = []
         for t in tom.model.Tables:
             t_name = t.Name
@@ -209,9 +216,7 @@ def list_tables(
                 new_data.update(
                     {
                         "Row Count": (
-                            rc[rc["DIMENSION_NAME"] == t_name][
-                                "DIMENSION_CARDINALITY"
-                            ].iloc[0]
+                            rc[rc["DIMENSION_NAME"] == t_name]["ROWS_COUNT"].iloc[0]
                             if not rc.empty
                             else 0
                         ),
@@ -221,24 +226,33 @@ def list_tables(
                         "Hierarchy Size": h_size,
                         "Relationship Size": r_size,
                         "User Hierarchy Size": u_size,
+                        "Partitions": int(len(t.Partitions)),
+                        "Columns": sum(
+                            1 for c in t.Columns if str(c.Type) != "RowNumber"
+                        ),
+                        "% DB": round((total_size / model_size) * 100, 2),
                     }
                 )
 
             rows.append(new_data)
 
-        int_cols = [
-            "Row Count",
-            "Total Size",
-            "Dictionary Size",
-            "Data Size",
-            "Hierarchy Size",
-            "Relationship Size",
-            "User Hierarchy Size",
-        ]
-        df[int_cols] = df[int_cols].astype(int)
-
         df = pd.DataFrame(rows)
 
+        if extended:
+            int_cols = [
+                "Row Count",
+                "Total Size",
+                "Dictionary Size",
+                "Data Size",
+                "Hierarchy Size",
+                "Relationship Size",
+                "User Hierarchy Size",
+                "Partitions",
+                "Columns",
+            ]
+            df[int_cols] = df[int_cols].astype(int)
+            df["% DB"] = df["% DB"].astype(float)
+
     return df
 
 
@@ -505,6 +519,7 @@ def list_columns(
     from sempy_labs.directlake._get_directlake_lakehouse import (
         get_direct_lake_lakehouse,
     )
+    from pyspark.sql import SparkSession
 
     workspace = fabric.resolve_workspace_name(workspace)
 
@@ -1274,6 +1289,8 @@ def list_relationships(
     workspace = fabric.resolve_workspace_name(workspace)
 
     dfR = fabric.list_relationships(dataset=dataset, workspace=workspace)
+    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
@@ -1393,48 +1410,6 @@ def list_kpis(dataset: str, workspace: Optional[str] = None) -> pd.DataFrame:
         return df
 
 
-def list_workspace_role_assignments(workspace: Optional[str] = None) -> pd.DataFrame:
-    """
-    Shows the members of a given workspace.
-
-    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 the members of a given workspace and their roles.
-    """
-
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    df = pd.DataFrame(columns=["User Name", "User Email", "Role Name", "Type"])
-
-    client = fabric.FabricRestClient()
-    response = client.get(f"/v1/workspaces/{workspace_id}/roleAssignments")
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-
-    responses = pagination(client, response)
-
-    for r in responses:
-        for i in r.get("value", []):
-            principal = i.get("principal", {})
-            new_data = {
-                "User Name": principal.get("displayName"),
-                "Role Name": i.get("role"),
-                "Type": principal.get("type"),
-                "User Email": principal.get("userDetails", {}).get("userPrincipalName"),
-            }
-            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-    return df
-
-
 def list_semantic_model_objects(
     dataset: str, workspace: Optional[str] = None
 ) -> pd.DataFrame:
@@ -1709,933 +1684,303 @@ def list_shortcuts(
     return df
 
 
-def list_custom_pools(workspace: Optional[str] = None) -> pd.DataFrame:
+def list_capacities() -> pd.DataFrame:
     """
-    Lists all `custom pools <https://learn.microsoft.com/fabric/data-engineering/create-custom-spark-pools>`_ within a workspace.
+    Shows the capacities and their properties.
 
     Parameters
     ----------
-    workspace : str, default=None
-        The name of the Fabric 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.
 
     Returns
     -------
     pandas.DataFrame
-        A pandas dataframe showing all the custom pools within the Fabric workspace.
+        A pandas dataframe showing the capacities and their properties
     """
 
-    # https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/list-workspace-custom-pools
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
     df = pd.DataFrame(
-        columns=[
-            "Custom Pool ID",
-            "Custom Pool Name",
-            "Type",
-            "Node Family",
-            "Node Size",
-            "Auto Scale Enabled",
-            "Auto Scale Min Node Count",
-            "Auto Scale Max Node Count",
-            "Dynamic Executor Allocation Enabled",
-            "Dynamic Executor Allocation Min Executors",
-            "Dynamic Executor Allocation Max Executors",
-        ]
+        columns=["Id", "Display Name", "Sku", "Region", "State", "Admins"]
     )
 
-    client = fabric.FabricRestClient()
-    response = client.get(f"/v1/workspaces/{workspace_id}/spark/pools")
+    client = fabric.PowerBIRestClient()
+    response = client.get("/v1.0/myorg/capacities")
     if response.status_code != 200:
         raise FabricHTTPException(response)
 
-    for i in response.json()["value"]:
-
-        aScale = i.get("autoScale", {})
-        d = i.get("dynamicExecutorAllocation", {})
-
+    for i in response.json().get("value", []):
         new_data = {
-            "Custom Pool ID": i.get("id"),
-            "Custom Pool Name": i.get("name"),
-            "Type": i.get("type"),
-            "Node Family": i.get("nodeFamily"),
-            "Node Size": i.get("nodeSize"),
-            "Auto Scale Enabled": aScale.get("enabled"),
-            "Auto Scale Min Node Count": aScale.get("minNodeCount"),
-            "Auto Scale Max Node Count": aScale.get("maxNodeCount"),
-            "Dynamic Executor Allocation Enabled": d.get("enabled"),
-            "Dynamic Executor Allocation Min Executors": d.get("minExecutors"),
-            "Dynamic Executor Allocation Max Executors": d.get("maxExecutors"),
+            "Id": i.get("id").lower(),
+            "Display Name": i.get("displayName"),
+            "Sku": i.get("sku"),
+            "Region": i.get("region"),
+            "State": i.get("state"),
+            "Admins": [i.get("admins", [])],
         }
         df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
-    bool_cols = ["Auto Scale Enabled", "Dynamic Executor Allocation Enabled"]
-    int_cols = [
-        "Auto Scale Min Node Count",
-        "Auto Scale Max Node Count",
-        "Dynamic Executor Allocation Enabled",
-        "Dynamic Executor Allocation Min Executors",
-        "Dynamic Executor Allocation Max Executors",
-    ]
-
-    df[bool_cols] = df[bool_cols].astype(bool)
-    df[int_cols] = df[int_cols].astype(int)
-
     return df
 
 
-def create_custom_pool(
-    pool_name: str,
-    node_size: str,
-    min_node_count: int,
-    max_node_count: int,
-    min_executors: int,
-    max_executors: int,
-    node_family: Optional[str] = "MemoryOptimized",
-    auto_scale_enabled: Optional[bool] = True,
-    dynamic_executor_allocation_enabled: Optional[bool] = True,
-    workspace: Optional[str] = None,
-):
-    """
-    Creates a `custom pool <https://learn.microsoft.com/fabric/data-engineering/create-custom-spark-pools>`_ within a workspace.
-
-    Parameters
-    ----------
-    pool_name : str
-        The custom pool name.
-    node_size : str
-        The `node size <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#nodesize>`_.
-    min_node_count : int
-        The `minimum node count <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#autoscaleproperties>`_.
-    max_node_count : int
-        The `maximum node count <https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#autoscaleproperties>`_.
-    min_executors : int
-        The `minimum executors <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#dynamicexecutorallocationproperties>`_.
-    max_executors : int
-        The `maximum executors <https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#dynamicexecutorallocationproperties>`_.
-    node_family : str, default='MemoryOptimized'
-        The `node family <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#nodefamily>`_.
-    auto_scale_enabled : bool, default=True
-        The status of `auto scale <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#autoscaleproperties>`_.
-    dynamic_executor_allocation_enabled : bool, default=True
-        The status of the `dynamic executor allocation <https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#dynamicexecutorallocationproperties>`_.
-    workspace : str, default=None
-        The name of the Fabric 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.
-    """
-
-    # https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    request_body = {
-        "name": pool_name,
-        "nodeFamily": node_family,
-        "nodeSize": node_size,
-        "autoScale": {
-            "enabled": auto_scale_enabled,
-            "minNodeCount": min_node_count,
-            "maxNodeCount": max_node_count,
-        },
-        "dynamicExecutorAllocation": {
-            "enabled": dynamic_executor_allocation_enabled,
-            "minExecutors": min_executors,
-            "maxExecutors": max_executors,
-        },
-    }
-
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"/v1/workspaces/{workspace_id}/spark/pools", json=request_body
-    )
-
-    if response.status_code != 201:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{pool_name}' spark pool has been created within the '{workspace}' workspace."
-    )
-
-
-def update_custom_pool(
-    pool_name: str,
-    node_size: Optional[str] = None,
-    min_node_count: Optional[int] = None,
-    max_node_count: Optional[int] = None,
-    min_executors: Optional[int] = None,
-    max_executors: Optional[int] = None,
-    node_family: Optional[str] = None,
-    auto_scale_enabled: Optional[bool] = None,
-    dynamic_executor_allocation_enabled: Optional[bool] = None,
-    workspace: Optional[str] = None,
-):
-    """
-    Updates the properties of a `custom pool <https://learn.microsoft.com/fabric/data-engineering/create-custom-spark-pools>`_ within a workspace.
-
-    Parameters
-    ----------
-    pool_name : str
-        The custom pool name.
-    node_size : str, default=None
-        The `node size <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#nodesize>`_.
-        Defaults to None which keeps the existing property setting.
-    min_node_count : int, default=None
-        The `minimum node count <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#autoscaleproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    max_node_count : int, default=None
-        The `maximum node count <https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#autoscaleproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    min_executors : int, default=None
-        The `minimum executors <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#dynamicexecutorallocationproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    max_executors : int, default=None
-        The `maximum executors <https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#dynamicexecutorallocationproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    node_family : str, default=None
-        The `node family <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#nodefamily>`_.
-        Defaults to None which keeps the existing property setting.
-    auto_scale_enabled : bool, default=None
-        The status of `auto scale <https://learn.microsoft.com/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#autoscaleproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    dynamic_executor_allocation_enabled : bool, default=None
-        The status of the `dynamic executor allocation <https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/create-workspace-custom-pool?tabs=HTTP#dynamicexecutorallocationproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    workspace : str, default=None
-        The name of the Fabric 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.
-    """
-
-    # https://learn.microsoft.com/en-us/rest/api/fabric/spark/custom-pools/update-workspace-custom-pool?tabs=HTTP
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    df = list_custom_pools(workspace=workspace)
-    df_pool = df[df["Custom Pool Name"] == pool_name]
-
-    if len(df_pool) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{pool_name}' custom pool does not exist within the '{workspace}'. Please choose a valid custom pool."
-        )
-
-    if node_family is None:
-        node_family = df_pool["Node Family"].iloc[0]
-    if node_size is None:
-        node_size = df_pool["Node Size"].iloc[0]
-    if auto_scale_enabled is None:
-        auto_scale_enabled = bool(df_pool["Auto Scale Enabled"].iloc[0])
-    if min_node_count is None:
-        min_node_count = int(df_pool["Min Node Count"].iloc[0])
-    if max_node_count is None:
-        max_node_count = int(df_pool["Max Node Count"].iloc[0])
-    if dynamic_executor_allocation_enabled is None:
-        dynamic_executor_allocation_enabled = bool(
-            df_pool["Dynami Executor Allocation Enabled"].iloc[0]
-        )
-    if min_executors is None:
-        min_executors = int(df_pool["Min Executors"].iloc[0])
-    if max_executors is None:
-        max_executors = int(df_pool["Max Executors"].iloc[0])
-
-    request_body = {
-        "name": pool_name,
-        "nodeFamily": node_family,
-        "nodeSize": node_size,
-        "autoScale": {
-            "enabled": auto_scale_enabled,
-            "minNodeCount": min_node_count,
-            "maxNodeCount": max_node_count,
-        },
-        "dynamicExecutorAllocation": {
-            "enabled": dynamic_executor_allocation_enabled,
-            "minExecutors": min_executors,
-            "maxExecutors": max_executors,
-        },
-    }
-
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"/v1/workspaces/{workspace_id}/spark/pools", json=request_body
-    )
-
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{pool_name}' spark pool within the '{workspace}' workspace has been updated."
-    )
-
-
-def delete_custom_pool(pool_name: str, workspace: Optional[str] = None):
-    """
-    Deletes a `custom pool <https://learn.microsoft.com/fabric/data-engineering/create-custom-spark-pools>`_ within a workspace.
-
-    Parameters
-    ----------
-    pool_name : str
-        The custom pool name.
-    workspace : str, default=None
-        The name of the Fabric 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)
-
-    dfL = list_custom_pools(workspace=workspace)
-    dfL_filt = dfL[dfL["Custom Pool Name"] == pool_name]
-
-    if len(dfL_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{pool_name}' custom pool does not exist within the '{workspace}' workspace."
-        )
-    poolId = dfL_filt["Custom Pool ID"].iloc[0]
-
-    client = fabric.FabricRestClient()
-    response = client.delete(f"/v1/workspaces/{workspace_id}/spark/pools/{poolId}")
-
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{pool_name}' spark pool has been deleted from the '{workspace}' workspace."
-    )
-
-
-def assign_workspace_to_capacity(capacity_name: str, workspace: Optional[str] = None):
-    """
-    Assigns a workspace to a capacity.
-
-    Parameters
-    ----------
-    capacity_name : str
-        The name of the capacity.
-    workspace : str, default=None
-        The name of the Fabric 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)
-
-    dfC = fabric.list_capacities()
-    dfC_filt = dfC[dfC["Display Name"] == capacity_name]
-
-    if len(dfC_filt) == 0:
-        raise ValueError(f"{icons.red_dot} The '{capacity_name}' capacity does not exist.")
-
-    capacity_id = dfC_filt["Id"].iloc[0]
-
-    request_body = {"capacityId": capacity_id}
-
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"/v1/workspaces/{workspace_id}/assignToCapacity",
-        json=request_body,
-    )
-
-    if response.status_code not in [200, 202]:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{workspace}' workspace has been assigned to the '{capacity_name}' capacity."
-    )
-
-
-def unassign_workspace_from_capacity(workspace: Optional[str] = None):
-    """
-    Unassigns a workspace from its assigned capacity.
-
-    Parameters
-    ----------
-    workspace : str, default=None
-        The name of the Fabric 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.
-    """
-
-    # https://learn.microsoft.com/en-us/rest/api/fabric/core/workspaces/unassign-from-capacity?tabs=HTTP
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"/v1/workspaces/{workspace_id}/unassignFromCapacity"
-    )
-
-    if response.status_code not in [200, 202]:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{workspace}' workspace has been unassigned from its capacity."
-    )
-
-
-def get_spark_settings(workspace: Optional[str] = None) -> pd.DataFrame:
+def list_reports_using_semantic_model(
+    dataset: str, workspace: Optional[str] = None
+) -> pd.DataFrame:
     """
-    Shows the spark settings for a workspace.
+    Shows a list of all the reports (in all workspaces) which use a given semantic model.
 
     Parameters
     ----------
+    dataset : str
+        Name of the semantic model.
     workspace : str, default=None
-        The name of the Fabric workspace.
+        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 the spark settings for a workspace.
+        A pandas dataframe showing the reports which use a given semantic model.
     """
 
-    # https://learn.microsoft.com/en-us/rest/api/fabric/spark/workspace-settings/get-spark-settings?tabs=HTTP
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
     df = pd.DataFrame(
         columns=[
-            "Automatic Log Enabled",
-            "High Concurrency Enabled",
-            "Customize Compute Enabled",
-            "Default Pool Name",
-            "Default Pool Type",
-            "Max Node Count",
-            "Max Executors",
-            "Environment Name",
-            "Runtime Version",
+            "Report Name",
+            "Report Id",
+            "Report Workspace Name",
+            "Report Workspace Id",
         ]
     )
 
-    client = fabric.FabricRestClient()
-    response = client.get(f"/v1/workspaces/{workspace_id}/spark/settings")
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
+    workspace = fabric.resolve_workspace_name(workspace)
+    dataset_id = resolve_dataset_id(dataset, workspace)
+    client = fabric.PowerBIRestClient()
+    response = client.get(
+        f"metadata/relations/downstream/dataset/{dataset_id}?apiVersion=3"
+    )
 
-    i = response.json()
-    p = i.get("pool")
-    dp = i.get("pool", {}).get("defaultPool", {})
-    sp = i.get("pool", {}).get("starterPool", {})
-    e = i.get("environment", {})
-
-    new_data = {
-        "Automatic Log Enabled": i.get("automaticLog").get("enabled"),
-        "High Concurrency Enabled": i.get("highConcurrency").get(
-            "notebookInteractiveRunEnabled"
-        ),
-        "Customize Compute Enabled": p.get("customizeComputeEnabled"),
-        "Default Pool Name": dp.get("name"),
-        "Default Pool Type": dp.get("type"),
-        "Max Node Count": sp.get("maxNodeCount"),
-        "Max Node Executors": sp.get("maxExecutors"),
-        "Environment Name": e.get("name"),
-        "Runtime Version": e.get("runtimeVersion"),
-    }
-    df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+    response_json = response.json()
 
-    bool_cols = [
-        "Automatic Log Enabled",
-        "High Concurrency Enabled",
-        "Customize Compute Enabled",
-    ]
-    int_cols = ["Max Node Count", "Max Executors"]
+    for i in response_json.get("artifacts", []):
+        object_workspace_id = i.get("workspace", {}).get("objectId")
+        object_type = i.get("typeName")
 
-    df[bool_cols] = df[bool_cols].astype(bool)
-    df[int_cols] = df[int_cols].astype(int)
+        if object_type == "Report":
+            new_data = {
+                "Report Name": i.get("displayName"),
+                "Report Id": i.get("objectId"),
+                "Report Workspace Name": fabric.resolve_workspace_name(
+                    object_workspace_id
+                ),
+                "Report Workspace Id": object_workspace_id,
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
     return df
 
 
-def update_spark_settings(
-    automatic_log_enabled: Optional[bool] = None,
-    high_concurrency_enabled: Optional[bool] = None,
-    customize_compute_enabled: Optional[bool] = None,
-    default_pool_name: Optional[str] = None,
-    max_node_count: Optional[int] = None,
-    max_executors: Optional[int] = None,
-    environment_name: Optional[str] = None,
-    runtime_version: Optional[str] = None,
-    workspace: Optional[str] = None,
-):
+def list_report_semantic_model_objects(
+    dataset: str, workspace: Optional[str] = None, extended: Optional[bool] = False
+) -> pd.DataFrame:
     """
-    Updates the spark settings for a workspace.
+    Shows a list of semantic model objects (i.e. columns, measures, hierarchies) used in all reports which feed data from
+    a given semantic model.
+
+    Requirement: Reports must be in the PBIR format.
 
     Parameters
     ----------
-    automatic_log_enabled : bool, default=None
-        The status of the `automatic log <https://learn.microsoft.com/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#automaticlogproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    high_concurrency_enabled : bool, default=None
-        The status of the `high concurrency <https://learn.microsoft.com/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#highconcurrencyproperties>`_ for notebook interactive run.
-        Defaults to None which keeps the existing property setting.
-    customize_compute_enabled : bool, default=None
-        `Customize compute <https://learn.microsoft.com/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#poolproperties>`_ configurations for items.
-        Defaults to None which keeps the existing property setting.
-    default_pool_name : str, default=None
-        `Default pool <https://learn.microsoft.com/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#poolproperties>`_ for workspace.
-        Defaults to None which keeps the existing property setting.
-    max_node_count : int, default=None
-        The `maximum node count <https://learn.microsoft.com/en-us/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#starterpoolproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    max_executors : int, default=None
-        The `maximum executors <https://learn.microsoft.com/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#starterpoolproperties>`_.
-        Defaults to None which keeps the existing property setting.
-    environment_name : str, default=None
-        The name of the `default environment <https://learn.microsoft.com/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#environmentproperties>`_. Empty string indicated there is no workspace default environment
-        Defaults to None which keeps the existing property setting.
-    runtime_version : str, default=None
-        The `runtime version <https://learn.microsoft.com/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP#environmentproperties>`_.
-        Defaults to None which keeps the existing property setting.
+    dataset : str
+        Name of the semantic model.
     workspace : str, default=None
-        The name of the Fabric workspace.
+        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.
+    extended: bool, default=False
+        If True, adds an extra column called 'Valid Semantic Model Object' which identifies whether the semantic model object used
+        in the report exists in the semantic model which feeds data to the report.
 
     Returns
     -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of semantic model objects (i.e. columns, measures, hierarchies) used in all reports which feed data from
+    a given semantic model.
     """
 
-    # https://learn.microsoft.com/en-us/rest/api/fabric/spark/workspace-settings/update-spark-settings?tabs=HTTP
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    dfS = get_spark_settings(workspace=workspace)
-
-    if automatic_log_enabled is None:
-        automatic_log_enabled = bool(dfS["Automatic Log Enabled"].iloc[0])
-    if high_concurrency_enabled is None:
-        high_concurrency_enabled = bool(dfS["High Concurrency Enabled"].iloc[0])
-    if customize_compute_enabled is None:
-        customize_compute_enabled = bool(dfS["Customize Compute Enabled"].iloc[0])
-    if default_pool_name is None:
-        default_pool_name = dfS["Default Pool Name"].iloc[0]
-    if max_node_count is None:
-        max_node_count = int(dfS["Max Node Count"].iloc[0])
-    if max_executors is None:
-        max_executors = int(dfS["Max Executors"].iloc[0])
-    if environment_name is None:
-        environment_name = dfS["Environment Name"].iloc[0]
-    if runtime_version is None:
-        runtime_version = dfS["Runtime Version"].iloc[0]
-
-    request_body = {
-        "automaticLog": {"enabled": automatic_log_enabled},
-        "highConcurrency": {"notebookInteractiveRunEnabled": high_concurrency_enabled},
-        "pool": {
-            "customizeComputeEnabled": customize_compute_enabled,
-            "defaultPool": {"name": default_pool_name, "type": "Workspace"},
-            "starterPool": {
-                "maxNodeCount": max_node_count,
-                "maxExecutors": max_executors,
-            },
-        },
-        "environment": {"name": environment_name, "runtimeVersion": runtime_version},
-    }
-
-    client = fabric.FabricRestClient()
-    response = client.patch(
-        f"/v1/workspaces/{workspace_id}/spark/settings", json=request_body
-    )
-
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The spark settings within the '{workspace}' workspace have been updated accordingly."
-    )
-
-
-def add_user_to_workspace(
-    email_address: str,
-    role_name: str,
-    principal_type: Optional[str] = "User",
-    workspace: Optional[str] = None,
-):
-    """
-    Adds a user to a workspace.
-
-    Parameters
-    ----------
-    email_address : str
-        The email address of the user.
-    role_name : str
-        The `role <https://learn.microsoft.com/rest/api/power-bi/groups/add-group-user#groupuseraccessright>`_ of the user within the workspace.
-    principal_type : str, default='User'
-        The `principal type <https://learn.microsoft.com/rest/api/power-bi/groups/add-group-user#principaltype>`_.
-    workspace : str, default=None
-        The name 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)
-
-    role_names = ["Admin", "Member", "Viewer", "Contributor"]
-    role_name = role_name.capitalize()
-    if role_name not in role_names:
-        raise ValueError(
-            f"{icons.red_dot} Invalid role. The 'role_name' parameter must be one of the following: {role_names}."
-        )
-    plural = "n" if role_name == "Admin" else ""
-    principal_types = ["App", "Group", "None", "User"]
-    principal_type = principal_type.capitalize()
-    if principal_type not in principal_types:
-        raise ValueError(
-            f"{icons.red_dot} Invalid princpal type. Valid options: {principal_types}."
-        )
-
-    client = fabric.PowerBIRestClient()
-
-    request_body = {
-        "emailAddress": email_address,
-        "groupUserAccessRight": role_name,
-        "principalType": principal_type,
-        "identifier": email_address,
-    }
-
-    response = client.post(
-        f"/v1.0/myorg/groups/{workspace_id}/users", json=request_body
-    )
+    from sempy_labs.report import ReportWrapper
+    from sempy_labs.tom import connect_semantic_model
 
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{email_address}' user has been added as a{plural} '{role_name}' within the '{workspace}' workspace."
+    dfRO = pd.DataFrame(
+        columns=[
+            "Report Name",
+            "Report Workspace Name",
+            "Table Name",
+            "Object Name",
+            "Object Type",
+            "Report Source",
+            "Report Source Object",
+        ]
     )
 
+    # Collect all reports which use the semantic model
+    dfR = list_reports_using_semantic_model(dataset=dataset, workspace=workspace)
 
-def delete_user_from_workspace(email_address: str, workspace: Optional[str] = None):
-    """
-    Removes a user from a workspace.
+    if len(dfR) == 0:
+        return dfRO
 
-    Parameters
-    ----------
-    email_address : str
-        The email address of the user.
-    workspace : str, default=None
-        The name 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.
+    for _, r in dfR.iterrows():
+        report_name = r["Report Name"]
+        report_workspace = r["Report Workspace Name"]
 
-    Returns
-    -------
-    """
+        rpt = ReportWrapper(report=report_name, workspace=report_workspace)
+        # Collect all semantic model objects used in the report
+        dfRSO = rpt.list_semantic_model_objects()
+        dfRSO["Report Name"] = report_name
+        dfRSO["Report Workspace Name"] = report_workspace
+        colName = "Report Name"
+        dfRSO.insert(0, colName, dfRSO.pop(colName))
+        colName = "Report Workspace Name"
+        dfRSO.insert(1, colName, dfRSO.pop(colName))
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+        dfRO = pd.concat([dfRO, dfRSO], ignore_index=True)
 
-    client = fabric.PowerBIRestClient()
-    response = client.delete(f"/v1.0/myorg/groups/{workspace_id}/users/{email_address}")
+    # Collect all semantic model objects
+    if extended:
+        with connect_semantic_model(
+            dataset=dataset, readonly=True, workspace=workspace
+        ) as tom:
+            for index, row in dfRO.iterrows():
+                object_type = row["Object Type"]
+                if object_type == "Measure":
+                    dfRO.at[index, "Valid Semantic Model Object"] = any(
+                        o.Name == row["Object Name"] for o in tom.all_measures()
+                    )
+                elif object_type == "Column":
+                    dfRO.at[index, "Valid Semantic Model Object"] = any(
+                        format_dax_object_name(c.Parent.Name, c.Name)
+                        == format_dax_object_name(row["Table Name"], row["Object Name"])
+                        for c in tom.all_columns()
+                    )
+                elif object_type == "Hierarchy":
+                    dfRO.at[index, "Valid Semantic Model Object"] = any(
+                        format_dax_object_name(h.Parent.Name, h.Name)
+                        == format_dax_object_name(row["Table Name"], row["Object Name"])
+                        for h in tom.all_hierarchies()
+                    )
 
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{email_address}' user has been removed from accessing the '{workspace}' workspace."
-    )
+    return dfRO
 
 
-def update_workspace_user(
-    email_address: str,
-    role_name: str,
-    principal_type: Optional[str] = "User",
+def list_semantic_model_object_report_usage(
+    dataset: str,
     workspace: Optional[str] = None,
-):
-    """
-    Updates a user's role within a workspace.
-
-    Parameters
-    ----------
-    email_address : str
-        The email address of the user.
-    role_name : str
-        The `role <https://learn.microsoft.com/rest/api/power-bi/groups/add-group-user#groupuseraccessright>`_ of the user within the workspace.
-    principal_type : str, default='User'
-        The `principal type <https://learn.microsoft.com/rest/api/power-bi/groups/add-group-user#principaltype>`_.
-    workspace : str, default=None
-        The name 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.
+    include_dependencies: Optional[bool] = False,
+    extended: Optional[bool] = False,
+) -> pd.DataFrame:
     """
+    Shows a list of semantic model objects and how many times they are referenced in all reports which rely on this semantic model.
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    role_names = ["Admin", "Member", "Viewer", "Contributor"]
-    role_name = role_name.capitalize()
-    if role_name not in role_names:
-        raise ValueError(
-            f"{icons.red_dot} Invalid role. The 'role_name' parameter must be one of the following: {role_names}."
-        )
-    principal_types = ["App", "Group", "None", "User"]
-    principal_type = principal_type.capitalize()
-    if principal_type not in principal_types:
-        raise ValueError(
-            f"{icons.red_dot} Invalid princpal type. Valid options: {principal_types}."
-        )
-
-    request_body = {
-        "emailAddress": email_address,
-        "groupUserAccessRight": role_name,
-        "principalType": principal_type,
-        "identifier": email_address,
-    }
-
-    client = fabric.PowerBIRestClient()
-    response = client.put(f"/v1.0/myorg/groups/{workspace_id}/users", json=request_body)
-
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-    print(
-        f"{icons.green_dot} The '{email_address}' user has been updated to a '{role_name}' within the '{workspace}' workspace."
-    )
-
-
-def list_workspace_users(workspace: Optional[str] = None) -> pd.DataFrame:
-    """
-    A list of all the users of a workspace and their roles.
+    Requirement: Reports must be in the PBIR format.
 
     Parameters
     ----------
+    dataset : str
+        Name of the semantic model.
     workspace : str, default=None
-        The name of the workspace.
+        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.
+    include_dependencies : bool, default=False
+        If True, includes measure dependencies.
+    extended: bool, default=False
+        If True, adds columns 'Total Size', 'Data Size', 'Dictionary Size', 'Hierarchy Size' based on Vertipaq statistics.
 
     Returns
     -------
     pandas.DataFrame
-        A pandas dataframe the users of a workspace and their properties.
-    """
-
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    df = pd.DataFrame(columns=["User Name", "Email Address", "Role", "Type", "User ID"])
-    client = fabric.FabricRestClient()
-    response = client.get(f"/v1/workspaces/{workspace_id}/roleAssignments")
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-
-    responses = pagination(client, response)
-
-    for r in responses:
-        for v in r.get("value", []):
-            p = v.get("principal", {})
-            new_data = {
-                "User Name": p.get("displayName"),
-                "User ID": p.get("id"),
-                "Type": p.get("type"),
-                "Role": v.get("role"),
-                "Email Address": p.get("userDetails", {}).get("userPrincipalName"),
-            }
-            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-    return df
-
-
-def list_capacities() -> pd.DataFrame:
-    """
-    Shows the capacities and their properties.
-
-    Parameters
-    ----------
-
-    Returns
-    -------
-    pandas.DataFrame
-        A pandas dataframe showing the capacities and their properties
-    """
-
-    df = pd.DataFrame(
-        columns=["Id", "Display Name", "Sku", "Region", "State", "Admins"]
-    )
-
-    client = fabric.PowerBIRestClient()
-    response = client.get("/v1.0/myorg/capacities")
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-
-    for i in response.json().get("value", []):
-        new_data = {
-            "Id": i.get("id").lower(),
-            "Display Name": i.get("displayName"),
-            "Sku": i.get("sku"),
-            "Region": i.get("region"),
-            "State": i.get("state"),
-            "Admins": [i.get("admins", [])],
-        }
-        df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-    return df
-
-
-def get_notebook_definition(
-    notebook_name: str, workspace: Optional[str] = None, decode: Optional[bool] = True
-):
+        A pandas dataframe showing a list of semantic model objects and how many times they are referenced in all reports which rely on this semantic model. By default, the dataframe
+        is sorted descending by 'Report Usage Count'.
     """
-    Obtains the notebook definition.
-
-    Parameters
-    ----------
-    notebook_name : str
-        The name of the notebook.
-    workspace : str, default=None
-        The name 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
-        If True, decodes the notebook definition file into .ipynb format.
-        If False, obtains the notebook definition file in base64 format.
 
-    Returns
-    -------
-    ipynb
-        The notebook definition.
-    """
+    from sempy_labs._model_dependencies import get_measure_dependencies
+    from sempy_labs._helper_functions import format_dax_object_name
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    workspace = fabric.resolve_workspace_name(workspace)
 
-    dfI = fabric.list_items(workspace=workspace, type="Notebook")
-    dfI_filt = dfI[dfI["Display Name"] == notebook_name]
+    dfR = list_report_semantic_model_objects(dataset=dataset, workspace=workspace)
+    usage_column_name = "Report Usage Count"
 
-    if len(dfI_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{notebook_name}' notebook does not exist within the '{workspace}' workspace."
+    if not include_dependencies:
+        final_df = (
+            dfR.groupby(["Table Name", "Object Name", "Object Type"])
+            .size()
+            .reset_index(name=usage_column_name)
         )
-
-    notebook_id = dfI_filt["Id"].iloc[0]
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"v1/workspaces/{workspace_id}/notebooks/{notebook_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"]
-    payload = df_items_filt["payload"].iloc[0]
-
-    if decode:
-        result = _decode_b64(payload)
     else:
-        result = payload
-
-    return result
-
-
-def import_notebook_from_web(
-    notebook_name: str,
-    url: str,
-    description: Optional[str] = None,
-    workspace: Optional[str] = None,
-):
-    """
-    Creates a new notebook within a workspace based on a Jupyter notebook hosted in the web.
+        df = pd.DataFrame(columns=["Table Name", "Object Name", "Object Type"])
+        dep = get_measure_dependencies(dataset=dataset, workspace=workspace)
 
-    Parameters
-    ----------
-    notebook_name : str
-        The name of the notebook to be created.
-    url : str
-        The url of the Jupyter Notebook (.ipynb)
-    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.
-        Defaults to None which resolves to the workspace of the attached lakehouse
-        or if no lakehouse attached, resolves to the workspace of the notebook.
+        for i, r in dfR.iterrows():
+            object_type = r["Object Type"]
+            table_name = r["Table Name"]
+            object_name = r["Object Name"]
+            new_data = {
+                "Table Name": table_name,
+                "Object Name": object_name,
+                "Object Type": object_type,
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+            if object_type == "Measure":
+                df_filt = dep[dep["Object Name"] == object_name][
+                    ["Referenced Table", "Referenced Object", "Referenced Object Type"]
+                ]
+                df_filt.rename(
+                    columns={
+                        "Referenced Table": "Table Name",
+                        "Referenced Object": "Object Name",
+                        "Referenced Object Type": "Object Type",
+                    },
+                    inplace=True,
+                )
 
-    Returns
-    -------
-    """
+                df = pd.concat([df, df_filt], ignore_index=True)
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-    client = fabric.FabricRestClient()
-    dfI = fabric.list_items(workspace=workspace, type="Notebook")
-    dfI_filt = dfI[dfI["Display Name"] == notebook_name]
-    if len(dfI_filt) > 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{notebook_name}' already exists within the '{workspace}' workspace."
+        final_df = (
+            df.groupby(["Table Name", "Object Name", "Object Type"])
+            .size()
+            .reset_index(name=usage_column_name)
         )
 
-    # Fix links to go to the raw github file
-    starting_text = "https://github.com/"
-    starting_text_len = len(starting_text)
-    if url.startswith(starting_text):
-        url = f"https://raw.githubusercontent.com/{url[starting_text_len:]}".replace(
-            "/blob/", "/"
+    if extended:
+        final_df["Object"] = format_dax_object_name(
+            final_df["Table Name"], final_df["Object Name"]
         )
-
-    response = requests.get(url)
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
-    file_content = response.content
-    notebook_payload = base64.b64encode(file_content)
-
-    request_body = {
-        "displayName": notebook_name,
-        "definition": {
-            "format": "ipynb",
-            "parts": [
-                {
-                    "path": "notebook-content.py",
-                    "payload": notebook_payload,
-                    "payloadType": "InlineBase64",
-                }
+        dfC = fabric.list_columns(dataset=dataset, workspace=workspace, extended=True)
+        dfC["Object"] = format_dax_object_name(dfC["Table Name"], dfC["Column Name"])
+        final_df = pd.merge(
+            final_df,
+            dfC[
+                [
+                    "Object",
+                    "Total Size",
+                    "Data Size",
+                    "Dictionary Size",
+                    "Hierarchy Size",
+                ]
             ],
-        },
-    }
-    if description is not None:
-        request_body["description"] = description
-
-    response = client.post(f"v1/workspaces/{workspace_id}/notebooks", json=request_body)
-
-    lro(client, response, status_codes=[201, 202])
-
-    print(
-        f"{icons.green_dot} The '{notebook_name}' notebook was created within the '{workspace}' workspace."
-    )
-
-
-def list_reports_using_semantic_model(
-    dataset: str, workspace: Optional[str] = None
-) -> pd.DataFrame:
-    """
-    Shows a list of all the reports (in all workspaces) which use a given 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.
+            on="Object",
+            how="left",
+        )
 
-    Returns
-    -------
-    pandas.DataFrame
-        A pandas dataframe showing the reports which use a given semantic model.
-    """
+        ext_int_cols = ["Total Size", "Data Size", "Dictionary Size", "Hierarchy Size"]
+        final_df[ext_int_cols] = final_df[ext_int_cols].fillna(0).astype(int)
+        final_df.drop("Object", axis=1, inplace=True)
 
-    df = pd.DataFrame(
-        columns=[
-            "Report Name",
-            "Report Id",
-            "Report Workspace Name",
-            "Report Workspace Id",
-        ]
-    )
+    int_cols = [usage_column_name]
+    final_df[int_cols] = final_df[int_cols].astype(int)
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    dataset_id = resolve_dataset_id(dataset, workspace)
-    client = fabric.PowerBIRestClient()
-    response = client.get(
-        f"metadata/relations/downstream/dataset/{dataset_id}?apiVersion=3"
+    final_df = final_df[final_df["Object Type"] != "Table"].sort_values(
+        by=usage_column_name, ascending=False
     )
 
-    response_json = response.json()
+    final_df.reset_index(drop=True, inplace=True)
 
-    for i in response_json.get("artifacts", []):
-        object_workspace_id = i.get("workspace", {}).get("objectId")
-        object_type = i.get("typeName")
-
-        if object_type == "Report":
-            new_data = {
-                "Report Name": i.get("displayName"),
-                "Report Id": i.get("objectId"),
-                "Report Workspace Name": fabric.resolve_workspace_name(
-                    object_workspace_id
-                ),
-                "Report Workspace Id": object_workspace_id,
-            }
-            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-    return df
+    return final_df