semantic-link-labs 0.8.6__py3-none-any.whl → 0.8.7__py3-none-any.whl

sempy_labs/admin/_external_data_share.py

@@ -0,0 +1,97 @@
+import sempy.fabric as fabric
+from uuid import UUID
+import sempy_labs._icons as icons
+from sempy.fabric.exceptions import FabricHTTPException
+import pandas as pd
+from sempy_labs.admin._basic_functions import _resolve_workspace_name_and_id
+
+
+def list_external_data_shares() -> pd.DataFrame:
+    """
+    Lists external data shares in the tenant. This function is for admins.
+
+    This is a wrapper function for the following API: `External Data Shares - List External Data Shares <https://learn.microsoft.com/rest/api/fabric/admin/external-data-shares/list-external-data-shares>`_.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of external data shares in the tenant.
+    """
+    df = pd.DataFrame(
+        columns=[
+            "External Data Share Id",
+            "Paths",
+            "Creater Principal Id",
+            "Creater Principal Name",
+            "Creater Principal Type",
+            "Creater Principal UPN",
+            "Recipient UPN",
+            "Status",
+            "Expiration Time UTC",
+            "Workspace Id",
+            "Item Id",
+            "Invitation URL",
+        ]
+    )
+
+    client = fabric.FabricRestClient()
+    response = client.get("/v1/admin/items/externalDataShares")
+
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    for i in response.json().get("value", []):
+        cp = i.get("creatorPrincipal", {})
+        new_data = {
+            "External Data Share Id": i.get("id"),
+            "Paths": [i.get("paths", [])],
+            "Creater Principal Id": cp.get("id"),
+            "Creater Principal Name": cp.get("displayName"),
+            "Creater Principal Type": cp.get("type"),
+            "Creater Principal UPN": cp.get("userDetails", {}).get("userPrincipalName"),
+            "Recipient UPN": i.get("recipient", {}).get("userPrincipalName"),
+            "Status": i.get("status"),
+            "Expiration Time UTC": i.get("expirationTimeUtc"),
+            "Workspace Id": i.get("workspaceId"),
+            "Item Id": i.get("itemId"),
+            "Invitation URL": i.get("invitationUrl"),
+        }
+
+        df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    date_time_columns = ["Expiration Time UTC"]
+    df[date_time_columns] = pd.to_datetime(df[date_time_columns])
+
+    return df
+
+
+def revoke_external_data_share(
+    external_data_share_id: UUID, item_id: UUID, workspace: str | UUID
+):
+    """
+    Revokes the specified external data share. Note: This action cannot be undone.
+
+    This is a wrapper function for the following API: `External Data Shares - Revoke External Data Share <https://learn.microsoft.com/rest/api/fabric/admin/external-data-shares/revoke-external-data-share>`_.
+
+    Parameters
+    ----------
+    external_data_share_id : UUID
+        The external data share ID.
+    item_id : int, default=None
+        The Item ID
+    workspace : str
+        The Fabric workspace name or id.
+    """
+    (workspace, workspace_id) = _resolve_workspace_name_and_id(workspace)
+
+    client = fabric.FabricRestClient()
+    response = client.post(
+        f"/v1/admin/workspaces/{workspace_id}/items/{item_id}/externalDataShares/{external_data_share_id}/revoke"
+    )
+
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    print(
+        f"{icons.green_dot} The '{external_data_share_id}' external data share for the '{item_id}' item within the '{workspace}' workspace has been revoked."
+    )

sempy_labs/admin/_git.py

@@ -0,0 +1,69 @@
+import sempy.fabric as fabric
+from sempy.fabric.exceptions import FabricHTTPException
+from sempy_labs._helper_functions import (
+    pagination,
+)
+import pandas as pd
+from sempy_labs.admin._basic_functions import list_workspaces
+
+
+def list_git_connections() -> pd.DataFrame:
+    """
+    Shows a list of Git connections.
+
+    This is a wrapper function for the following API: `Workspaces - List Git Connections <https://learn.microsoft.com/rest/api/fabric/admin/workspaces/list-git-connections>`_.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of Git connections.
+    """
+
+    client = fabric.FabricRestClient()
+    response = client.get("/v1/admin/workspaces/discoverGitConnections")
+
+    df = pd.DataFrame(
+        columns=[
+            "Workspace Id",
+            "Organization Name",
+            "Owner Name",
+            "Project Name",
+            "Git Provider Type",
+            "Repository Name",
+            "Branch Name",
+            "Directory Name",
+        ]
+    )
+
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    responses = pagination(client, response)
+
+    for r in responses:
+        for v in r.get("value", []):
+            git = v.get("gitProviderDetails", {})
+            new_data = {
+                "Workspace Id": v.get("workspaceId"),
+                "Organization Name": git.get("organizationName"),
+                "Owner Name": git.get("ownerName"),
+                "Project Name": git.get("projectName"),
+                "Git Provider Type": git.get("gitProviderType"),
+                "Repository Name": git.get("repositoryName"),
+                "Branch Name": git.get("branchName"),
+                "Directory Name": git.get("directoryName"),
+            }
+
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    dfW = list_workspaces()
+    df = pd.merge(
+        df, dfW[["Id", "Name"]], left_on="Workspace Id", right_on="Id", how="left"
+    )
+    new_col_name = "Workspace Name"
+    df = df.rename(columns={"Name": new_col_name})
+    df.insert(1, new_col_name, df.pop(new_col_name))
+
+    df = df.drop(columns=["Id"])
+
+    return df

sempy_labs/admin/_items.py

@@ -0,0 +1,264 @@
+import sempy.fabric as fabric
+import pandas as pd
+from typing import Optional, Tuple
+from uuid import UUID
+import sempy_labs._icons as icons
+from sempy.fabric.exceptions import FabricHTTPException
+from sempy_labs.admin._basic_functions import (
+    _resolve_capacity_name_and_id,
+    _resolve_workspace_name_and_id,
+)
+from sempy_labs._helper_functions import (
+    pagination,
+    _is_valid_uuid,
+    _build_url,
+)
+
+
+def _resolve_item_id(
+    item_name: str,
+    type: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
+) -> UUID:
+
+    dfI = list_items(workspace=workspace, type=type)
+    dfI_filt = dfI[dfI["Item Name"] == item_name]
+
+    if len(dfI_filt) == 0:
+        raise ValueError(
+            f"The '{item_name}' {type} does not exist within the '{workspace}' workspace or is not of type '{type}'."
+        )
+
+    return dfI_filt["Item Id"].iloc[0]
+
+
+def _resolve_item_name_and_id(
+    item: str,
+    type: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
+    **kwargs,
+) -> Tuple[str, UUID]:
+    if "item_name" in kwargs:
+        print(
+            "The 'item_name' parameter has been deprecated. Please replace this parameter with 'item' from the function going forward."
+        )
+        item = item_name
+        del kwargs["item_name"]
+
+    dfI = list_items(workspace=workspace, type=type, item=item)
+
+    if len(dfI) > 1:
+        raise ValueError(
+            f"There are more than 1 item with the name '{item}'. Please specify the 'type' and/or 'workspace' to be more precise."
+        )
+
+    try:
+        item_name = dfI["Item Name"].iloc[0]
+        item_id = dfI["Item Id"].iloc[0]
+    except Exception:
+        raise ValueError(
+            f"The '{item}' {type} does not exist within the '{workspace}' workspace or is not of type '{type}'."
+        )
+
+    return item_name, item_id
+
+
+def list_items(
+    capacity: Optional[str | UUID] = None,
+    workspace: Optional[str] = None,
+    state: Optional[str] = None,
+    type: Optional[str] = None,
+    item: Optional[str | UUID] = None,
+    **kwargs,
+) -> pd.DataFrame:
+    """
+    Shows a list of active Fabric and Power BI items.
+
+    This is a wrapper function for the following API: `Items - List Items <https://learn.microsoft.com/rest/api/fabric/admin/items/list-items>`_.
+
+    Parameters
+    ----------
+    capacity : str | UUID, default=None
+        The capacity name or id.
+    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.
+    state : str, default=None
+        The item state.
+    type : str, default=None
+        The item type.
+    item : str | UUID, default=None
+        Item id or name to filter the list.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of active Fabric and Power BI items.
+    """
+    if "capacity_name" in kwargs:
+        print(
+            "The 'capacity_name' parameter has been deprecated. Please replace this parameter with 'capacity' from the function going forward."
+        )
+        capacity = kwargs["capacity_name"]
+        del kwargs["capacity_name"]
+
+    df = pd.DataFrame(
+        columns=[
+            "Item Id",
+            "Item Name",
+            "Type",
+            "Description",
+            "State",
+            "Last Updated Date",
+            "Creator Principal Id",
+            "Creator Principal Display Name",
+            "Creator Principal Type",
+            "Creator User Principal Name",
+            "Workspace Id",
+            "Capacity Id",
+        ]
+    )
+
+    client = fabric.FabricRestClient()
+
+    params = {}
+
+    url = "/v1/admin/items"
+
+    if capacity is not None:
+        params["capacityId"] = _resolve_capacity_name_and_id(capacity)[1]
+
+    if workspace is not None:
+        params["workspaceId"] = _resolve_workspace_name_and_id(workspace)[1]
+
+    if state is not None:
+        params["state"] = state
+
+    if type is not None:
+        params["type"] = type
+
+    url = _build_url(url, params)
+
+    response = client.get(url)
+
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    responses = pagination(client, response)
+
+    for r in responses:
+        for v in r.get("itemEntities", []):
+            new_data = {
+                "Item Id": v.get("id"),
+                "Type": v.get("type"),
+                "Item Name": v.get("name"),
+                "Description": v.get("description"),
+                "State": v.get("state"),
+                "Last Updated Date": v.get("lastUpdatedDate"),
+                "Creator Principal Id": v.get("creatorPrincipal", {}).get("id"),
+                "Creator Principal Display Name": v.get("creatorPrincipal", {}).get(
+                    "displayName"
+                ),
+                "Creator Principal Type": v.get("creatorPrincipal", {}).get("type"),
+                "Creator User Principal Name": v.get("creatorPrincipal", {})
+                .get("userDetails", {})
+                .get("userPrincipalName"),
+                "Workspace Id": v.get("workspaceId"),
+                "Capacity Id": v.get("capacityId"),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    if item is not None:
+        if _is_valid_uuid(item):
+            df = df[df["Item Id"] == item]
+        else:
+            df = df[df["Item Name"] == item]
+
+    return df
+
+
+def list_item_access_details(
+    item: str | UUID = None,
+    type: str = None,
+    workspace: Optional[str | UUID] = None,
+    **kwargs,
+) -> pd.DataFrame:
+    """
+    Returns a list of users (including groups and service principals) and lists their workspace roles.
+
+    This is a wrapper function for the following API: `Items - List Item Access Details <https://learn.microsoft.com/rest/api/fabric/admin/items/list-item-access-details>`_.
+
+    Parameters
+    ----------
+    item : str
+        Name or id of the Fabric item.
+    type : str, default=None
+        Type of Fabric item.
+    workspace : str, default=None
+        The Fabric workspace name or id.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of users (including groups and service principals) and lists their workspace roles.
+    """
+    if "item_name" in kwargs:
+        print(
+            "The 'item_name' parameter has been deprecated. Please replace this parameter with 'item' from the function going forward."
+        )
+        item = kwargs["item_name"]
+        del kwargs["item_name"]
+
+    if item is None or type is None:
+        raise ValueError(
+            f"{icons.red_dot} The parameter 'item' and 'type' are mandatory."
+        )
+
+    client = fabric.FabricRestClient()
+
+    workspace_name, workspace_id = _resolve_workspace_name_and_id(workspace)
+    item_name, item_id = _resolve_item_name_and_id(
+        item=item, type=type, workspace=workspace_name
+    )
+
+    df = pd.DataFrame(
+        columns=[
+            "User Id",
+            "User Name",
+            "User Type",
+            "User Principal Name",
+            "Item Name",
+            "Item Type",
+            "Item Id",
+            "Permissions",
+            "Additional Permissions",
+        ]
+    )
+
+    response = client.get(f"/v1/admin/workspaces/{workspace_id}/items/{item_id}/users")
+
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    for v in response.json().get("accessDetails", []):
+        new_data = {
+            "User Id": v.get("principal", {}).get("id"),
+            "User Name": v.get("principal", {}).get("displayName"),
+            "User Type": v.get("principal", {}).get("type"),
+            "User Principal Name": v.get("principal", {})
+            .get("userDetails", {})
+            .get("userPrincipalName"),
+            "Item Type": v.get("itemAccessDetails", {}).get("type"),
+            "Permissions": v.get("itemAccessDetails", {}).get("permissions"),
+            "Additional Permissions": v.get("itemAccessDetails", {}).get(
+                "additionalPermissions"
+            ),
+            "Item Name": item_name,
+            "Item Id": item_id,
+        }
+        df = pd.concat([df, pd.DataFrame([new_data])], ignore_index=True)
+
+    return df

sempy_labs/admin/_scanner.py

@@ -0,0 +1,104 @@
+import sempy.fabric as fabric
+from typing import Optional, List
+from uuid import UUID
+from sempy.fabric.exceptions import FabricHTTPException
+import numpy as np
+import time
+from sempy_labs.admin._basic_functions import list_workspaces
+
+
+def scan_workspaces(
+    data_source_details: bool = False,
+    dataset_schema: bool = False,
+    dataset_expressions: bool = False,
+    lineage: bool = False,
+    artifact_users: bool = False,
+    workspace: Optional[str | List[str] | UUID | List[UUID]] = None,
+) -> dict:
+    """
+    Get the inventory and details of the tenant.
+
+    This is a wrapper function for the following APIs:
+        `Admin - WorkspaceInfo PostWorkspaceInfo <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-post-workspace-info>`_.
+        `Admin - WorkspaceInfo GetScanStatus <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-get-scan-status>`_.
+        `Admin - WorkspaceInfo GetScanResult <https://learn.microsoft.com/en-gb/rest/api/power-bi/admin/workspace-info-get-scan-result>`_.
+
+    Parameters
+    ----------
+    data_source_details : bool, default=False
+        Whether to return dataset expressions (DAX and Mashup queries). If you set this parameter to true, you must fully enable metadata scanning in order for data to be returned. For more information, see Enable tenant settings for metadata scanning.
+    dataset_schema: bool = False
+        Whether to return dataset schema (tables, columns and measures). If you set this parameter to true, you must fully enable metadata scanning in order for data to be returned. For more information, see Enable tenant settings for metadata scanning.
+    dataset_expressions : bool, default=False
+        Whether to return data source details
+    lineage : bool, default=False
+        Whether to return lineage info (upstream dataflows, tiles, data source IDs)
+    artifact_users : bool, default=False
+        Whether to return user details for a Power BI item (such as a report or a dashboard)
+    workspace : str | List[str] | UUID | List[UUID], default=None
+        The required workspace name(s) or id(s) to be scanned
+
+    Returns
+    -------
+    dictionary
+        A json object with the scan result.
+    """
+    scan_result = {
+        "workspaces": [],
+        "datasourceInstances": [],
+        "misconfiguredDatasourceInstances": [],
+    }
+
+    client = fabric.FabricRestClient()
+
+    if workspace is None:
+        workspace = fabric.resolve_workspace_name()
+
+    if isinstance(workspace, str):
+        workspace = [workspace]
+
+    workspace_list = []
+
+    dfW = list_workspaces()
+    workspace_list = dfW[dfW["Name"].isin(workspace)]["Id"].tolist()
+    workspace_list = workspace_list + dfW[dfW["Id"].isin(workspace)]["Id"].tolist()
+
+    workspaces = np.array(workspace_list)
+    batch_size = 99
+    for i in range(0, len(workspaces), batch_size):
+        batch = workspaces[i : i + batch_size].tolist()
+        request_body = {"workspaces": batch}
+
+        response_clause = f"/v1.0/myorg/admin/workspaces/getInfo?lineage={lineage}&datasourceDetails={data_source_details}&datasetSchema={dataset_schema}&datasetExpressions={dataset_expressions}&getArtifactUsers={artifact_users}"
+        response = client.post(response_clause, json=request_body)
+
+        if response.status_code != 202:
+            raise FabricHTTPException(response)
+        scan_id = response.json()["id"]
+        scan_status = response.json().get("status")
+        while scan_status not in ["Succeeded", "Failed"]:
+            time.sleep(1)
+            response = client.get(f"/v1.0/myorg/admin/workspaces/scanStatus/{scan_id}")
+            scan_status = response.json().get("status")
+        if scan_status == "Failed":
+            raise FabricHTTPException(response)
+        response = client.get(f"/v1.0/myorg/admin/workspaces/scanResult/{scan_id}")
+        if response.status_code != 200:
+            raise FabricHTTPException(response)
+
+        responseJson = response.json()
+
+        if "workspaces" in responseJson:
+            scan_result["workspaces"].extend(responseJson["workspaces"])
+
+        if "datasourceInstances" in responseJson:
+            scan_result["datasourceInstances"].extend(
+                responseJson["datasourceInstances"]
+            )
+
+        if "misconfiguredDatasourceInstances" in responseJson:
+            scan_result["misconfiguredDatasourceInstances"].extend(
+                responseJson["misconfiguredDatasourceInstances"]
+            )
+
+    return scan_result

sempy_labs/directlake/_dl_helper.py

@@ -112,7 +112,9 @@ def generate_direct_lake_semantic_model(
     """
 
     from sempy_labs.lakehouse import get_lakehouse_tables, get_lakehouse_columns
-    from sempy_labs.directlake import get_shared_expression
+    from sempy_labs.directlake._generate_shared_expression import (
+        generate_shared_expression,
+    )
     from sempy_labs.tom import connect_semantic_model
     from sempy_labs._generate_semantic_model import create_blank_semantic_model
     from sempy_labs._refresh_semantic_model import refresh_semantic_model
@@ -141,7 +143,9 @@ def generate_direct_lake_semantic_model(
             )
 
     dfLC = get_lakehouse_columns(lakehouse=lakehouse, workspace=lakehouse_workspace)
-    expr = get_shared_expression(lakehouse=lakehouse, workspace=lakehouse_workspace)
+    expr = generate_shared_expression(
+        item_name=lakehouse, item_type="Lakehouse", workspace=lakehouse_workspace
+    )
     dfD = fabric.list_datasets(workspace=workspace)
     dfD_filt = dfD[dfD["Dataset Name"] == dataset]
 

sempy_labs/directlake/_get_shared_expression.py

@@ -1,8 +1,4 @@
-import sempy.fabric as fabric
-from sempy_labs._helper_functions import resolve_lakehouse_name
-from sempy_labs._list_functions import list_lakehouses
 from typing import Optional
-import sempy_labs._icons as icons
 
 
 def get_shared_expression(
@@ -26,36 +22,10 @@ def get_shared_expression(
     str
         Shows the expression which can be used to connect a Direct Lake semantic model to its SQL Endpoint.
     """
-
-    workspace = fabric.resolve_workspace_name(workspace)
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, workspace)
-
-    dfL = list_lakehouses(workspace=workspace)
-    lakeDetail = dfL[dfL["Lakehouse Name"] == lakehouse]
-
-    sqlEPCS = lakeDetail["SQL Endpoint Connection String"].iloc[0]
-    sqlepid = lakeDetail["SQL Endpoint ID"].iloc[0]
-    provStatus = lakeDetail["SQL Endpoint Provisioning Status"].iloc[0]
-
-    parts = sqlEPCS.split(".", 1)
-    if parts:
-        parts[0] = parts[0].upper()
-
-    sqlEPCS = ".".join(parts)
-
-    if provStatus == "InProgress":
-        raise ValueError(
-            f"{icons.red_dot} The SQL Endpoint for the '{lakehouse}' lakehouse within the '{workspace}' workspace has not yet been provisioned. Please wait until it has been provisioned."
-        )
-
-    sh = (
-        'let\n\tdatabase = Sql.Database("'
-        + sqlEPCS
-        + '", "'
-        + sqlepid
-        + '")\nin\n\tdatabase'
+    from sempy_labs.directlake._generate_shared_expression import (
+        generate_shared_expression,
     )
 
-    return sh
+    return generate_shared_expression(
+        item_name=lakehouse, item_type="Lakehouse", workspace=workspace
+    )

sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py

@@ -1,5 +1,4 @@
 import sempy.fabric as fabric
-from sempy_labs.directlake._get_shared_expression import get_shared_expression
 from sempy_labs.directlake._generate_shared_expression import generate_shared_expression
 from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
@@ -56,7 +55,9 @@ def update_direct_lake_model_lakehouse_connection(
 
     icons.sll_tags.append("UpdateDLConnection")
 
-    shEx = get_shared_expression(lakehouse, lakehouse_workspace)
+    shEx = generate_shared_expression(
+        item_name=lakehouse, item_type="Lakehouse", workspace=lakehouse_workspace
+    )
 
     with connect_semantic_model(
         dataset=dataset, readonly=False, workspace=workspace

sempy_labs/migration/_migrate_tables_columns_to_semantic_model.py

@@ -1,6 +1,6 @@
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs.directlake._get_shared_expression import get_shared_expression
+from sempy_labs.directlake._generate_shared_expression import generate_shared_expression
 from sempy_labs._helper_functions import resolve_lakehouse_name, retry
 from sempy_labs.lakehouse._lakehouse import lakehouse_attached
 from sempy_labs.tom import connect_semantic_model
@@ -71,7 +71,9 @@ def migrate_tables_columns_to_semantic_model(
             "To attach a lakehouse to a notebook, go to the the 'Explorer' window to the left, click 'Lakehouses' to add your lakehouse to this notebook"
             "\nLearn more here: https://learn.microsoft.com/fabric/data-engineering/lakehouse-notebook-explore#add-or-remove-a-lakehouse"
         )
-    shEx = get_shared_expression(lakehouse, lakehouse_workspace)
+    shEx = generate_shared_expression(
+        item_name=lakehouse, item_type="Lakehouse", workspace=lakehouse_workspace
+    )
 
     dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
     dfT = fabric.list_tables(dataset=dataset, workspace=workspace)

sempy_labs/report/_generate_report.py

@@ -179,7 +179,9 @@ def update_report_from_reportjson(
     )
 
 
-def get_report_definition(report: str, workspace: Optional[str] = None) -> pd.DataFrame:
+def get_report_definition(
+    report: str, workspace: Optional[str] = None, return_dataframe: bool = True
+) -> pd.DataFrame | dict:
     """
     Gets the collection of definition files of a report.
 
@@ -193,10 +195,12 @@ def get_report_definition(report: str, workspace: Optional[str] = None) -> pd.Da
         The Fabric workspace name in which the report resides.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
+    return_dataframe : bool, default=True
+        If True, returns a dataframe. If False, returns a json dictionary.
 
     Returns
     -------
-    pandas.DataFrame
+    pandas.DataFrame | dict
         The collection of report definition files within a pandas dataframe.
     """
 
@@ -209,9 +213,11 @@ def get_report_definition(report: str, workspace: Optional[str] = None) -> pd.Da
     )
 
     result = lro(client, response).json()
-    rdef = pd.json_normalize(result["definition"]["parts"])
 
-    return rdef
+    if return_dataframe:
+        return pd.json_normalize(result["definition"]["parts"])
+    else:
+        return result
 
 
 @log