semantic-link-labs 0.9.10__py3-none-any.whl → 0.9.11__py3-none-any.whl

sempy_labs/lakehouse/_blobs.py

@@ -11,6 +11,7 @@ from typing import Optional, List
 import sempy_labs._icons as icons
 import xml.etree.ElementTree as ET
 import pandas as pd
+from sempy.fabric.exceptions import FabricHTTPException
 
 
 def _request_blob_api(
@@ -18,6 +19,7 @@ def _request_blob_api(
     method: str = "get",
     payload: Optional[dict] = None,
     status_codes: int | List[int] = 200,
+    uses_pagination: bool = False,
 ):
 
     import requests
@@ -31,21 +33,41 @@ def _request_blob_api(
 
     headers = {
         "Authorization": f"Bearer {token}",
-        "Content-Type": "application/json",
+        "Content-Type": "application/xml",
         "x-ms-version": "2025-05-05",
     }
 
-    response = requests.request(
-        method.upper(),
-        f"https://onelake.blob.fabric.microsoft.com/{request}",
-        headers=headers,
-        json=payload,
-    )
+    base_url = "https://onelake.blob.fabric.microsoft.com/"
+    full_url = f"{base_url}{request}"
+    results = []
+
+    while True:
+        response = requests.request(
+            method.upper(),
+            full_url,
+            headers=headers,
+            data=payload if method.lower() != "get" else None,
+        )
+
+        if response.status_code not in status_codes:
+            raise FabricHTTPException(response)
+
+        if not uses_pagination:
+            return response
+
+        # Parse XML to find blobs and NextMarker
+        root = ET.fromstring(response.content)
+        results.append(root)
+
+        next_marker = root.findtext(".//NextMarker")
+        if not next_marker:
+            break  # No more pages
 
-    if response.status_code not in status_codes:
-        raise FabricHTTPException(response)
+        # Append the marker to the original request (assuming query string format)
+        delimiter = "&" if "?" in request else "?"
+        full_url = f"{base_url}{request}{delimiter}marker={next_marker}"
 
-    return response
+    return results
 
 
 @log
@@ -90,12 +112,6 @@ def list_blobs(
             )
         path_prefix = f"{workspace_id}/{lakehouse_id}/{container}"
 
-    response = _request_blob_api(
-        request=f"{path_prefix}?restype=container&comp=list&include=deleted"
-    )
-    root = ET.fromstring(response.content)
-    response_json = _xml_to_dict(root)
-
     columns = {
         "Blob Name": "str",
         "Is Deleted": "bool",
@@ -122,37 +138,55 @@ def list_blobs(
 
     df = _create_dataframe(columns=columns)
 
-    for blob in (
-        response_json.get("EnumerationResults", {}).get("Blobs", {}).get("Blob", {})
-    ):
-        p = blob.get("Properties", {})
-        new_data = {
-            "Blob Name": blob.get("Name"),
-            "Is Deleted": blob.get("Deleted", False),
-            "Deletion Id": blob.get("DeletionId"),
-            "Creation Time": p.get("Creation-Time"),
-            "Expiry Time": p.get("Expiry-Time"),
-            "Etag": p.get("Etag"),
-            "Resource Type": p.get("ResourceType"),
-            "Content Length": p.get("Content-Length"),
-            "Content Type": p.get("Content-Type"),
-            "Content Encoding": p.get("Content-Encoding"),
-            "Content Language": p.get("Content-Language"),
-            "Content CRC64": p.get("Content-CRC64"),
-            "Content MD5": p.get("Content-MD5"),
-            "Cache Control": p.get("Cache-Control"),
-            "Content Disposition": p.get("Content-Disposition"),
-            "Blob Type": p.get("BlobType"),
-            "Access Tier": p.get("AccessTier"),
-            "Access Tier Inferred": p.get("AccessTierInferred"),
-            "Server Encrypted": p.get("ServerEncrypted"),
-            "Deleted Time": p.get("DeletedTime"),
-            "Remaining Retention Days": p.get("RemainingRetentionDays"),
-        }
-
-        df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-    _update_dataframe_datatypes(dataframe=df, column_map=columns)
+    url = f"{path_prefix}?restype=container&comp=list&include=deleted"
+
+    responses = _request_blob_api(
+        request=url,
+        uses_pagination=True,
+    )
+
+    dfs = []
+    for root in responses:
+        response_json = _xml_to_dict(root)
+
+        blobs = (
+            response_json.get("EnumerationResults", {}).get("Blobs", {}).get("Blob", [])
+        )
+
+        if isinstance(blobs, dict):
+            blobs = [blobs]
+
+        for blob in blobs:
+            p = blob.get("Properties", {})
+            new_data = {
+                "Blob Name": blob.get("Name"),
+                "Is Deleted": blob.get("Deleted", False),
+                "Deletion Id": blob.get("DeletionId"),
+                "Creation Time": p.get("Creation-Time"),
+                "Expiry Time": p.get("Expiry-Time"),
+                "Etag": p.get("Etag"),
+                "Resource Type": p.get("ResourceType"),
+                "Content Length": p.get("Content-Length"),
+                "Content Type": p.get("Content-Type"),
+                "Content Encoding": p.get("Content-Encoding"),
+                "Content Language": p.get("Content-Language"),
+                "Content CRC64": p.get("Content-CRC64"),
+                "Content MD5": p.get("Content-MD5"),
+                "Cache Control": p.get("Cache-Control"),
+                "Content Disposition": p.get("Content-Disposition"),
+                "Blob Type": p.get("BlobType"),
+                "Access Tier": p.get("AccessTier"),
+                "Access Tier Inferred": p.get("AccessTierInferred"),
+                "Server Encrypted": p.get("ServerEncrypted"),
+                "Deleted Time": p.get("DeletedTime"),
+                "Remaining Retention Days": p.get("RemainingRetentionDays"),
+            }
+
+            dfs.append(pd.DataFrame(new_data, index=[0]))
+
+    if dfs:
+        df = pd.concat(dfs, ignore_index=True)
+        _update_dataframe_datatypes(dataframe=df, column_map=columns)
 
     return df
 
@@ -182,7 +216,7 @@ def recover_lakehouse_object(
     workspace_id = resolve_workspace_id(workspace)
     lakehouse_id = resolve_lakehouse_id(lakehouse, workspace_id)
 
-    blob_path_prefix = f"{lakehouse_id}/{file_path}"
+    blob_name = f"{lakehouse_id}/{file_path}"
 
     container = file_path.split("/")[0]
     if container not in ["Tables", "Files"]:
@@ -190,29 +224,45 @@ def recover_lakehouse_object(
             f"{icons.red_dot} Invalid container '{container}' within the file_path parameter. Expected 'Tables' or 'Files'."
         )
 
-    df = list_blobs(lakehouse=lakehouse, workspace=workspace, container=container)
+    # Undelete the blob
+    print(f"{icons.in_progress} Attempting to recover the '{blob_name}' blob...")
 
-    for _, r in df.iterrows():
-        blob_name = r.get("Blob Name")
-        is_deleted = r.get("Is Deleted")
-        if blob_name.startswith(blob_path_prefix) and is_deleted:
-            print(f"{icons.in_progress} Restoring the '{blob_name}' blob...")
-            _request_blob_api(
-                request=f"{workspace_id}/{lakehouse_id}/{file_path}?comp=undelete",
-                method="put",
+    try:
+        _request_blob_api(
+            request=f"{workspace_id}/{lakehouse_id}/{file_path}?comp=undelete",
+            method="put",
+        )
+        print(
+            f"{icons.green_dot} The '{blob_name}' blob recover attempt was successful."
+        )
+    except FabricHTTPException as e:
+        if e.status_code == 404:
+            print(
+                f"{icons.warning} The '{blob_name}' blob was not found. No action taken."
+            )
+        else:
+            print(
+                f"{icons.red_dot} An error occurred while recovering the '{blob_name}' blob: {e}"
             )
-            print(f"{icons.green_dot} The '{blob_name}' blob has been restored.")
 
 
-def _get_user_delegation_key():
+def get_user_delegation_key():
+    """
+    Gets a key that can be used to sign a user delegation SAS (shared access signature). A user delegation SAS grants access to Azure Blob Storage resources by using Microsoft Entra credentials.
 
-    # https://learn.microsoft.com/rest/api/storageservices/get-user-delegation-key
+    This is a wrapper function for the following API: `Get User Delegation Key <https://learn.microsoft.com/rest/api/storageservices/get-user-delegation-key>`_.
+
+    Returns
+    -------
+    str
+        The user delegation key value.
+    """
 
     from datetime import datetime, timedelta, timezone
 
     utc_now = datetime.now(timezone.utc)
     start_time = utc_now + timedelta(minutes=2)
-    expiry_time = start_time + timedelta(minutes=45)
+    expiry_time = start_time + timedelta(minutes=60)
     start_str = start_time.strftime("%Y-%m-%dT%H:%M:%SZ")
     expiry_str = expiry_time.strftime("%Y-%m-%dT%H:%M:%SZ")
 
@@ -223,9 +273,11 @@ def _get_user_delegation_key():
     </KeyInfo>"""
 
     response = _request_blob_api(
-        request="restype=service&comp=userdelegationkey",
+        request="?restype=service&comp=userdelegationkey",
         method="post",
         payload=payload,
     )
 
-    return response.content
+    root = ET.fromstring(response.content)
+    response_json = _xml_to_dict(root)
+    return response_json.get("UserDelegationKey", {}).get("Value", None)

sempy_labs/lakehouse/_get_lakehouse_tables.py

@@ -9,8 +9,6 @@ from sempy_labs._helper_functions import (
     save_as_delta_table,
     _base_api,
     _create_dataframe,
-    resolve_workspace_id,
-    resolve_lakehouse_id,
     _read_delta_table,
     _get_delta_table,
     _mount,
@@ -85,16 +83,6 @@ def get_lakehouse_tables(
     if count_rows:  # Setting countrows defaults to extended=True
         extended = True
 
-    if (
-        workspace_id != resolve_workspace_id()
-        and lakehouse_id != resolve_lakehouse_id()
-        and count_rows
-    ):
-        raise ValueError(
-            f"{icons.red_dot} If 'count_rows' is set to True, you must run this function against the default lakehouse attached to the notebook. "
-            "Count rows runs a spark query and cross-workspace spark queries are currently not supported."
-        )
-
     responses = _base_api(
         request=f"v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/tables",
         uses_pagination=True,
@@ -123,7 +111,7 @@ def get_lakehouse_tables(
     if extended:
         sku_value = get_sku_size(workspace_id)
         guardrail = get_directlake_guardrails_for_sku(sku_value)
-        local_path = _mount()
+        local_path = _mount(lakehouse=lakehouse_id, workspace=workspace_id)
 
         df["Files"], df["Row Groups"], df["Table Size"] = None, None, None
         if count_rows:

sempy_labs/lakehouse/_helper.py

@@ -0,0 +1,211 @@
+from uuid import UUID
+from typing import Optional, Literal
+import pyarrow.dataset as ds
+from sempy_labs._helper_functions import (
+    _mount,
+    delete_item,
+    _base_api,
+    resolve_workspace_name_and_id,
+    resolve_lakehouse_name_and_id,
+)
+from sempy._utils._log import log
+import sempy_labs._icons as icons
+import os
+
+
+@log
+def is_v_ordered(
+    table_name: str,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+    schema: Optional[str] = None,
+) -> bool:
+    """
+    Checks if a delta table is v-ordered.
+
+    Parameters
+    ----------
+    table_name : str
+        The name of the table to check.
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    schema : str, optional
+        The schema of the table to check. If not provided, the default schema is used.
+
+    Returns
+    -------
+    bool
+        True if the table is v-ordered, False otherwise.
+    """
+
+    local_path = _mount(lakehouse=lakehouse, workspace=workspace)
+    table_path = (
+        f"{local_path}/Tables/{schema}/{table_name}"
+        if schema
+        else f"{local_path}/Tables/{table_name}"
+    )
+    ds_schema = ds.dataset(table_path).schema.metadata
+
+    return any(b"vorder" in key for key in ds_schema.keys())
+
+
+def delete_lakehouse(
+    lakehouse: str | UUID, workspace: Optional[str | UUID] = None
+) -> None:
+    """
+    Deletes a lakehouse.
+
+    This is a wrapper function for the following API: `Items - Delete Lakehouse <https://learn.microsoft.com/rest/api/fabric/lakehouse/items/delete-lakehouse>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    lakehouse : str | uuid.UUID
+        The name or ID of the lakehouse to delete.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    delete_item(item=lakehouse, item_type="lakehouse", workspace=workspace)
+
+
+def update_lakehouse(
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Updates a lakehouse.
+
+    This is a wrapper function for the following API: `Items - Update Lakehouse <https://learn.microsoft.com/rest/api/fabric/lakehouse/items/update-lakehouse>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    name: str, default=None
+        The new name of the lakehouse.
+        Defaults to None which does not update the name.
+    description: str, default=None
+        The new description of the lakehouse.
+        Defaults to None which does not update the description.
+    lakehouse : str | uuid.UUID, default=None
+        The name or ID of the lakehouse to update.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    if not name and not description:
+        raise ValueError(
+            f"{icons.red_dot} Either name or description must be provided."
+        )
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse, workspace_id
+    )
+
+    payload = {}
+    if name:
+        payload["displayName"] = name
+    if description:
+        payload["description"] = description
+
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}",
+        method="patch",
+        client="fabric_sp",
+        payload=payload,
+    )
+
+    print(
+        f"{icons.green_dot} The '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has been updated accordingly."
+    )
+
+
+@log
+def load_table(
+    table_name: str,
+    file_path: str,
+    mode: Literal["Overwrite", "Append"],
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Loads a table into a lakehouse. Currently only files are supported, not folders.
+
+    This is a wrapper function for the following API: `Tables - Load Table <https://learn.microsoft.com/rest/api/fabric/lakehouse/tables/load-table>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    table_name : str
+        The name of the table to load.
+    file_path : str
+        The path to the data to load.
+    mode : Literal["Overwrite", "Append"]
+        The mode to use when loading the data.
+        "Overwrite" will overwrite the existing data.
+        "Append" will append the data to the existing data.
+    lakehouse : str | uuid.UUID, default=None
+        The name or ID of the lakehouse to load the table into.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        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_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse, workspace_id
+    )
+
+    file_extension = os.path.splitext(file_path)[1]
+
+    payload = {
+        "relativePath": file_path,
+        "pathType": "File",
+        "mode": mode,
+        "formatOptions": {},
+    }
+
+    if file_extension == ".csv":
+        payload["formatOptions"] = {"format": "Csv", "header": True, "delimiter": ","}
+    elif file_extension == ".parquet":
+        payload["formatOptions"] = {
+            "format": "Parquet",
+            "header": True,
+        }
+    # Solve for loading folders
+    # elif file_extension == '':
+    #    payload['pathType'] = "Folder"
+    #    payload["recursive"] = recursive
+    #    payload['formatOptions']
+    else:
+        raise NotImplementedError()
+
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/tables/{table_name}/load",
+        client="fabric_sp",
+        method="post",
+        status_codes=202,
+        lro_return_status_code=True,
+    )
+
+    print(
+        f"{icons.green_dot} The '{table_name}' table has been loaded into the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace."
+    )

sempy_labs/lakehouse/_lakehouse.py

@@ -113,7 +113,7 @@ def vacuum_lakehouse_tables(
     Parameters
     ----------
     tables : str | List[str] | None
-        The table(s) to vacuum. If no tables are specified, all tables in the lakehouse will be optimized.
+        The table(s) to vacuum. If no tables are specified, all tables in the lakehouse will be vacuumed.
     lakehouse : str | uuid.UUID, default=None
         The Fabric lakehouse name or ID.
         Defaults to None which resolves to the lakehouse attached to the notebook.

sempy_labs/lakehouse/_livy_sessions.py

@@ -0,0 +1,137 @@
+from sempy_labs._helper_functions import (
+    resolve_workspace_id,
+    resolve_lakehouse_id,
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+)
+import pandas as pd
+from typing import Optional
+from uuid import UUID
+
+
+def list_livy_sessions(
+    lakehouse: Optional[str | UUID] = None, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a list of livy sessions from the specified item identifier.
+
+    This is a wrapper function for the following API: `Livy Sessions - List Livy Sessions <https://learn.microsoft.com/rest/api/fabric/lakehouse/livy-sessions/list-livy-sessions>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of livy sessions from the specified item identifier.
+    """
+
+    columns = {
+        "Spark Application Id": "string",
+        "State:": "string",
+        "Livy Id": "string",
+        "Origin": "string",
+        "Attempt Number": "int",
+        "Max Number Of Attempts": "int",
+        "Livy Name": "string",
+        "Submitter Id": "string",
+        "Submitter Type": "string",
+        "Item Workspace Id": "string",
+        "Item Id": "string",
+        "Item Reference Type": "string",
+        "Item Name": "string",
+        "Item Type": "string",
+        "Job Type": "string",
+        "Submitted Date Time": "str",
+        "Start Date Time": "str",
+        "End Date Time": "string",
+        "Queued Duration Value": "int",
+        "Queued Duration Time Unit": "string",
+        "Running Duration Value": "int",
+        "Running Duration Time Unit": "string",
+        "Total Duration Value": "int",
+        "Total Duration Time Unit": "string",
+        "Job Instance Id": "string",
+        "Creator Item Workspace Id": "string",
+        "Creator Item Id": "string",
+        "Creator Item Reference Type": "string",
+        "Creator Item Name": "string",
+        "Creator Item Type": "string",
+        "Cancellation Reason": "string",
+        "Capacity Id": "string",
+        "Operation Name": "string",
+        "Runtime Version": "string",
+        "Livy Session Item Resource Uri": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    workspace_id = resolve_workspace_id(workspace)
+    lakehouse_id = resolve_lakehouse_id(lakehouse, workspace_id)
+
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/livySessions",
+        uses_pagination=True,
+        client="fabric_sp",
+    )
+
+    dfs = []
+
+    for r in responses:
+        for v in r.get("value", []):
+            queued_duration = v.get("queuedDuration", {})
+            running_duration = v.get("runningDuration", {})
+            total_duration = v.get("totalDuration", {})
+            new_data = {
+                "Spark Application Id": v.get("sparkApplicationId"),
+                "State:": v.get("state"),
+                "Livy Id": v.get("livyId"),
+                "Origin": v.get("origin"),
+                "Attempt Number": v.get("attemptNumber"),
+                "Max Number Of Attempts": v.get("maxNumberOfAttempts"),
+                "Livy Name": v.get("livyName"),
+                "Submitter Id": v["submitter"].get("id"),
+                "Submitter Type": v["submitter"].get("type"),
+                "Item Workspace Id": v["item"].get("workspaceId"),
+                "Item Id": v["item"].get("itemId"),
+                "Item Reference Type": v["item"].get("referenceType"),
+                "Item Name": v.get("itemName"),
+                "Item Type": v.get("itemType"),
+                "Job Type": v.get("jobType"),
+                "Submitted Date Time": v.get("submittedDateTime"),
+                "Start Date Time": v.get("startDateTime"),
+                "End Date Time": v.get("endDateTime"),
+                "Queued Duration Value": queued_duration.get("value"),
+                "Queued Duration Time Unit": queued_duration.get("timeUnit"),
+                "Running Duration Value": running_duration.get("value"),
+                "Running Duration Time Unit": running_duration.get("timeUnit"),
+                "Total Duration Value": total_duration.get("value"),
+                "Total Duration Time Unit": total_duration.get("timeUnit"),
+                "Job Instance Id": v.get("jobInstanceId"),
+                "Creator Item Workspace Id": v["creatorItem"].get("workspaceId"),
+                "Creator Item Id": v["creatorItem"].get("itemId"),
+                "Creator Item Reference Type": v["creatorItem"].get("referenceType"),
+                "Creator Item Name": v.get("creatorItemName"),
+                "Creator Item Type": v.get("creatorItemType"),
+                "Cancellation Reason": v.get("cancellationReason"),
+                "Capacity Id": v.get("capacityId"),
+                "Operation Name": v.get("operationName"),
+                "Runtime Version": v.get("runtimeVersion"),
+                "Livy Session Item Resource Uri": v.get("livySessionItemResourceUri"),
+            }
+            dfs.append(pd.DataFrame(new_data, index=[0]))
+
+    if dfs:
+        df = pd.concat(dfs, ignore_index=True)
+        _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df

sempy_labs/report/_download_report.py

@@ -22,7 +22,7 @@ def download_report(
     """
     Downloads the specified report from the specified workspace to a Power BI .pbix file.
 
-    This is a wrapper function for the following API: `Reports - Export Report In Group <https://learn.microsoft.com/rest/api/power-bi/reports/export-report-in-group>`.
+    This is a wrapper function for the following API: `Reports - Export Report In Group <https://learn.microsoft.com/rest/api/power-bi/reports/export-report-in-group>`_.
 
     Parameters
     ----------

sempy_labs/report/_generate_report.py

@@ -178,6 +178,7 @@ def update_report_from_reportjson(
     )
 
 
+@log
 def get_report_definition(
     report: str | UUID,
     workspace: Optional[str | UUID] = None,
@@ -206,7 +207,10 @@ def get_report_definition(
     """
 
     return get_item_definition(
-        item=report, type="Report", workspace=workspace, return_dataframe=True
+        item=report,
+        type="Report",
+        workspace=workspace,
+        return_dataframe=return_dataframe,
     )