semantic-link-labs 0.9.5__py3-none-any.whl → 0.9.7__py3-none-any.whl

sempy_labs/lakehouse/_blobs.py

@@ -0,0 +1,231 @@
+from sempy_labs._helper_functions import (
+    resolve_workspace_id,
+    resolve_lakehouse_id,
+    _xml_to_dict,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+)
+from sempy._utils._log import log
+from uuid import UUID
+from typing import Optional, List
+import sempy_labs._icons as icons
+import xml.etree.ElementTree as ET
+import pandas as pd
+
+
+def _request_blob_api(
+    request: str,
+    method: str = "get",
+    payload: Optional[dict] = None,
+    status_codes: int | List[int] = 200,
+):
+
+    import requests
+    import notebookutils
+    from sempy.fabric.exceptions import FabricHTTPException
+
+    if isinstance(status_codes, int):
+        status_codes = [status_codes]
+
+    token = notebookutils.credentials.getToken("storage")
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+        "x-ms-version": "2025-05-05",
+    }
+
+    response = requests.request(
+        method.upper(),
+        f"https://onelake.blob.fabric.microsoft.com/{request}",
+        headers=headers,
+        json=payload,
+    )
+
+    if response.status_code not in status_codes:
+        raise FabricHTTPException(response)
+
+    return response
+
+
+@log
+def list_blobs(
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+    container: Optional[str] = None,
+) -> pd.DataFrame:
+    """
+    Returns a list of blobs for a given lakehouse.
+
+    This function leverages the following API: `List Blobs <https://learn.microsoft.com/rest/api/storageservices/list-blobs?tabs=microsoft-entra-id>`_.
+
+    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 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.
+    container : str, default=None
+        The container name to list blobs from. If None, lists all blobs in the lakehouse.
+        Valid values are "Tables" or "Files". If not specified, the function will list all blobs in the lakehouse.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of blobs in the lakehouse.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    lakehouse_id = resolve_lakehouse_id(lakehouse, workspace_id)
+
+    if container is None:
+        path_prefix = f"{workspace_id}/{lakehouse_id}"
+    else:
+        if container not in ["Tables", "Files"]:
+            raise ValueError(
+                f"{icons.red_dot} Invalid container '{container}' within the file_path parameter. Expected 'Tables' or 'Files'."
+            )
+        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",
+        "Deletion Id": "str",
+        "Creation Time": "datetime",
+        "Expiry Time": "datetime",
+        "Etag": "str",
+        "Resource Type": "str",
+        "Content Length": "int",
+        "Content Type": "str",
+        "Content Encoding": "str",
+        "Content Language": "str",
+        "Content CRC64": "str",
+        "Content MD5": "str",
+        "Cache Control": "str",
+        "Content Disposition": "str",
+        "Blob Type": "str",
+        "Access Tier": "str",
+        "Access Tier Inferred": "str",
+        "Server Encrypted": "bool",
+        "Deleted Time": "str",
+        "Remaining Retention Days": "str",
+    }
+
+    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)
+
+    return df
+
+
+@log
+def recover_lakehouse_object(
+    file_path: str,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Recovers an object (i.e. table, file, folder) in a lakehouse from a deleted state. Only `soft-deleted objects <https://learn.microsoft.com/fabric/onelake/onelake-disaster-recovery#soft-delete-for-onelake-files>`_ can be recovered (deleted for less than 7 days).
+
+    Parameters
+    ----------
+    file_path : str
+        The file path of the object to restore. For example: "Tables/my_delta_table".
+    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.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    lakehouse_id = resolve_lakehouse_id(lakehouse, workspace_id)
+
+    blob_path_prefix = f"{lakehouse_id}/{file_path}"
+
+    container = file_path.split("/")[0]
+    if container not in ["Tables", "Files"]:
+        raise ValueError(
+            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)
+
+    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",
+            )
+            print(f"{icons.green_dot} The '{blob_name}' blob has been restored.")
+
+
+def _get_user_delegation_key():
+
+    # https://learn.microsoft.com/rest/api/storageservices/get-user-delegation-key
+
+    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)
+    start_str = start_time.strftime("%Y-%m-%dT%H:%M:%SZ")
+    expiry_str = expiry_time.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    payload = f"""<?xml version="1.0" encoding="utf-8"?>
+    <KeyInfo>
+        <Start>{start_str}</Start>
+        <Expiry>{expiry_str}</Expiry>
+    </KeyInfo>"""
+
+    response = _request_blob_api(
+        request="restype=service&comp=userdelegationkey",
+        method="post",
+        payload=payload,
+    )
+
+    return response.content

sempy_labs/lakehouse/_shortcuts.py

@@ -5,6 +5,7 @@ from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     _base_api,
     _create_dataframe,
+    resolve_workspace_name,
 )
 from sempy._utils._log import log
 from typing import Optional
@@ -16,29 +17,33 @@ from sempy.fabric.exceptions import FabricHTTPException
 @log
 def create_shortcut_onelake(
     table_name: str,
-    source_lakehouse: str,
+    source_lakehouse: str | UUID,
     source_workspace: str | UUID,
-    destination_lakehouse: str,
+    destination_lakehouse: Optional[str | UUID] = None,
     destination_workspace: Optional[str | UUID] = None,
     shortcut_name: Optional[str] = None,
     source_path: str = "Tables",
     destination_path: str = "Tables",
+    shortcut_conflict_policy: Optional[str] = None,
 ):
     """
     Creates a `shortcut <https://learn.microsoft.com/fabric/onelake/onelake-shortcuts>`_ to a delta table in OneLake.
 
     This is a wrapper function for the following API: `OneLake Shortcuts - Create Shortcut <https://learn.microsoft.com/rest/api/fabric/core/onelake-shortcuts/create-shortcut>`_.
 
+    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 table name for which a shortcut will be created.
-    source_lakehouse : str
+    source_lakehouse : str | uuid.UUID
         The Fabric lakehouse in which the table resides.
     source_workspace : str | uuid.UUID
         The name or ID of the Fabric workspace in which the source lakehouse exists.
-    destination_lakehouse : str
+    destination_lakehouse : str | uuid.UUID, default=None
         The Fabric lakehouse in which the shortcut will be created.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
     destination_workspace : str | uuid.UUID, default=None
         The name or ID of the Fabric workspace in which the shortcut will be created.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -49,6 +54,8 @@ def create_shortcut_onelake(
         A string representing the full path to the table/file in the source lakehouse, including either "Files" or "Tables". Examples: Tables/FolderName/SubFolderName; Files/FolderName/SubFolderName.
     destination_path: str, default="Tables"
         A string representing the full path where the shortcut is created, including either "Files" or "Tables". Examples: Tables/FolderName/SubFolderName; Files/FolderName/SubFolderName.
+    shortcut_conflict_policy : str, default=None
+        When provided, it defines the action to take when a shortcut with the same name and path already exists. The default action is 'Abort'. Additional ShortcutConflictPolicy types may be added over time.
     """
 
     if not (source_path.startswith("Files") or source_path.startswith("Tables")):
@@ -101,7 +108,8 @@ def create_shortcut_onelake(
     # Check if the shortcut already exists
     try:
         response = _base_api(
-            request=f"/v1/workspaces/{destination_workspace_id}/items/{destination_lakehouse_id}/shortcuts/{destination_path}/{actual_shortcut_name}"
+            request=f"/v1/workspaces/{destination_workspace_id}/items/{destination_lakehouse_id}/shortcuts/{destination_path}/{actual_shortcut_name}",
+            client="fabric_sp",
         )
         response_json = response.json()
         del response_json["target"]["type"]
@@ -117,11 +125,21 @@ def create_shortcut_onelake(
     except FabricHTTPException:
         pass
 
+    url = f"/v1/workspaces/{destination_workspace_id}/items/{destination_lakehouse_id}/shortcuts"
+
+    if shortcut_conflict_policy:
+        if shortcut_conflict_policy not in ["Abort", "GenerateUniqueName"]:
+            raise ValueError(
+                f"{icons.red_dot} The 'shortcut_conflict_policy' parameter must be either 'Abort' or 'GenerateUniqueName'."
+            )
+        url += f"?shortcutConflictPolicy={shortcut_conflict_policy}"
+
     _base_api(
-        request=f"/v1/workspaces/{destination_workspace_id}/items/{destination_lakehouse_id}/shortcuts",
+        request=url,
         payload=payload,
         status_codes=201,
         method="post",
+        client="fabric_sp",
     )
 
     print(
@@ -209,6 +227,8 @@ def delete_shortcut(
 
     This is a wrapper function for the following API: `OneLake Shortcuts - Delete Shortcut <https://learn.microsoft.com/rest/api/fabric/core/onelake-shortcuts/delete-shortcut>`_.
 
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
     Parameters
     ----------
     shortcut_name : str
@@ -232,6 +252,7 @@ def delete_shortcut(
     _base_api(
         request=f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts/{shortcut_path}/{shortcut_name}",
         method="delete",
+        client="fabric_sp",
     )
 
     print(
@@ -286,7 +307,7 @@ def list_shortcuts(
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     path: str, default=None
-        The path within lakehouse where to look for shortcuts. If provied, must start with either "Files" or "Tables". Examples: Tables/FolderName/SubFolderName; Files/FolderName/SubFolderName.
+        The path within lakehouse where to look for shortcuts. If provided, must start with either "Files" or "Tables". Examples: Tables/FolderName/SubFolderName; Files/FolderName/SubFolderName.
         Defaults to None which will retun all shortcuts on the given lakehouse
 
     Returns
@@ -359,7 +380,7 @@ def list_shortcuts(
             source_item_id = tgt.get(sources.get(tgt_type), {}).get("itemId")
             bucket = tgt.get(sources.get(tgt_type), {}).get("bucket")
             source_workspace_name = (
-                fabric.resolve_workspace_name(source_workspace_id)
+                resolve_workspace_name(workspace_id=source_workspace_id)
                 if source_workspace_id is not None
                 else None
             )

sempy_labs/migration/_direct_lake_to_import.py

@@ -1,11 +1,16 @@
 import sempy
 from uuid import UUID
 import sempy_labs._icons as icons
+from typing import Optional
 
 
-def migrate_direct_lake_to_import(dataset: str | UUID, workspace: str | UUID):
+def migrate_direct_lake_to_import(
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    mode: str = "import",
+):
     """
-    Migrates a semantic model from Direct Lake mode to import mode. After running this function, you must go to the semantic model settings and update the cloud connection. Not doing so will result in an inablity to refresh/use the semantic model.
+    Migrates a semantic model or specific table(s) from a Direct Lake mode to import or DirectQuery mode. After running this function, you must go to the semantic model settings and update the cloud connection. Not doing so will result in an inablity to refresh/use the semantic model.
 
     Parameters
     ----------
@@ -15,12 +20,29 @@ def migrate_direct_lake_to_import(dataset: str | UUID, workspace: str | UUID):
         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.
+    mode : str, default="import"
+        The mode to migrate to. Can be either "import" or "directquery".
     """
 
     sempy.fabric._client._utils._init_analysis_services()
     import Microsoft.AnalysisServices.Tabular as TOM
     from sempy_labs.tom import connect_semantic_model
 
+    modes = {
+        "import": "Import",
+        "directquery": "DirectQuery",
+        "dq": "DirectQuery",
+    }
+
+    # Resolve mode
+    mode = mode.lower()
+    actual_mode = modes.get(mode)
+    if actual_mode is None:
+        raise ValueError(f"Invalid mode '{mode}'. Must be one of {list(modes.keys())}.")
+
+    # if isinstance(tables, str):
+    #     tables = [tables]
+
     with connect_semantic_model(
         dataset=dataset, workspace=workspace, readonly=False
     ) as tom:
@@ -31,7 +53,14 @@ def migrate_direct_lake_to_import(dataset: str | UUID, workspace: str | UUID):
             )
             return
 
-        for t in tom.model.Tables:
+        # if tables is None:
+        table_list = [t for t in tom.model.Tables]
+        # else:
+        #    table_list = [t for t in tom.model.Tables if t.Name in tables]
+        # if not table_list:
+        #    raise ValueError(f"{icons.red_dot} No tables found to migrate.")
+
+        for t in table_list:
             table_name = t.Name
             if t.Partitions.Count == 1 and all(
                 p.Mode == TOM.ModeType.DirectLake for p in t.Partitions
@@ -51,16 +80,24 @@ def migrate_direct_lake_to_import(dataset: str | UUID, workspace: str | UUID):
                     table_name=table_name,
                     partition_name=partition_name,
                     expression=expression,
-                    mode="Import",
+                    mode=actual_mode,
                 )
                 # Remove Direct Lake partition
                 tom.remove_object(object=p)
+                # if tables is not None:
+                #    print(
+                #        f"{icons.green_dot} The '{table_name}' table has been migrated to '{actual_mode}' mode."
+                #    )
 
         tom.model.Model.DefaultMode = TOM.ModeType.Import
+    # if tables is None:
+    print(
+        f"{icons.green_dot} All tables which were in Direct Lake mode have been migrated to '{actual_mode}' mode."
+    )
 
-        # Check
-        # for t in tom.model.Tables:
-        #    if t.Partitions.Count == 1 and all(p.Mode == TOM.ModeType.Import for p in t.Partitions) and t.CalculationGroup is None:
-        #        p = next(p for p in t.Partitions)
-        #        print(p.Name)
-        #        print(p.Source.Expression)
+    # Check
+    # for t in tom.model.Tables:
+    #    if t.Partitions.Count == 1 and all(p.Mode == TOM.ModeType.Import for p in t.Partitions) and t.CalculationGroup is None:
+    #        p = next(p for p in t.Partitions)
+    #        print(p.Name)
+    #        print(p.Source.Expression)

sempy_labs/migration/_migration_validation.py

@@ -42,10 +42,6 @@ def migration_validation(
             f"{icons.red_dot} The 'dataset' and 'new_dataset' parameters are both set to '{dataset}'. These parameters must be set to different values."
         )
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    if new_dataset_workspace is None:
-        new_dataset_workspace = workspace
-
     icons.sll_tags.append("DirectLakeMigration")
 
     dfA = list_semantic_model_objects(dataset=dataset, workspace=workspace)

sempy_labs/report/__init__.py

@@ -1,3 +1,6 @@
+from sempy_labs.report._save_report import (
+    save_report_as_pbip,
+)
 from sempy_labs.report._reportwrapper import (
     ReportWrapper,
 )
@@ -46,4 +49,5 @@ __all__ = [
     "run_report_bpa",
     "get_report_datasources",
     "download_report",
+    "save_report_as_pbip",
 ]

sempy_labs/report/_download_report.py

@@ -3,10 +3,11 @@ import sempy_labs._icons as icons
 from typing import Optional
 from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
-    resolve_lakehouse_name,
+    resolve_lakehouse_name_and_id,
     _base_api,
     resolve_item_id,
     _mount,
+    resolve_workspace_name,
 )
 from sempy_labs.lakehouse._lakehouse import lakehouse_attached
 from uuid import UUID
@@ -44,11 +45,8 @@ def download_report(
         )
 
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
-    lakehouse_id = fabric.get_lakehouse_id()
-    lakehouse_workspace = fabric.resolve_workspace_name()
-    lakehouse_name = resolve_lakehouse_name(
-        lakehouse_id=lakehouse_id, workspace=lakehouse_workspace
-    )
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id()
+    lakehouse_workspace = resolve_workspace_name()
 
     download_types = ["LiveConnect", "IncludeModel"]
     if download_type not in download_types:

sempy_labs/report/_generate_report.py

@@ -319,9 +319,9 @@ def _create_report(
 
     from sempy_labs.report import report_rebind
 
-    report_workspace = fabric.resolve_workspace_name(report_workspace)
-    report_workspace_id = fabric.resolve_workspace_id(report_workspace)
-    dataset_workspace = fabric.resolve_workspace_name(dataset_workspace)
+    (report_workspace_name, report_workspace_id) = resolve_workspace_name_and_id(
+        workspace=report_workspace
+    )
 
     dfR = fabric.list_reports(workspace=report_workspace)
     dfR_filt = dfR[dfR["Name"] == report]
@@ -338,7 +338,7 @@ def _create_report(
         )
 
         print(
-            f"{icons.green_dot} The '{report}' report has been created within the '{report_workspace}'"
+            f"{icons.green_dot} The '{report}' report has been created within the '{report_workspace_name}'"
         )
         updated_report = True
     # Update the report if it exists
@@ -352,12 +352,12 @@ def _create_report(
             status_codes=None,
         )
         print(
-            f"{icons.green_dot} The '{report}' report has been updated within the '{report_workspace}'"
+            f"{icons.green_dot} The '{report}' report has been updated within the '{report_workspace_name}'"
         )
         updated_report = True
     else:
         raise ValueError(
-            f"{icons.red_dot} The '{report}' report within the '{report_workspace}' workspace already exists and the 'overwrite' parameter was set to False."
+            f"{icons.red_dot} The '{report}' report within the '{report_workspace_name}' workspace already exists and the 'overwrite' parameter was set to False."
         )
 
     # Rebind the report to the semantic model to make sure it is pointed at the correct semantic model

sempy_labs/report/_report_functions.py

@@ -18,6 +18,7 @@ from sempy_labs._helper_functions import (
     _base_api,
     _create_spark_session,
     _mount,
+    resolve_workspace_id,
 )
 from typing import List, Optional, Union
 from sempy._utils._log import log
@@ -115,9 +116,9 @@ def report_dependency_tree(workspace: Optional[str | UUID] = None):
     dfR.rename(columns={"Name": "Report Name"}, inplace=True)
     dfR = dfR[["Report Name", "Dataset Name"]]
 
-    report_icon = "\U0001F4F6"
-    dataset_icon = "\U0001F9CA"
-    workspace_icon = "\U0001F465"
+    report_icon = "\U0001f4f6"
+    dataset_icon = "\U0001f9ca"
+    workspace_icon = "\U0001f465"
 
     node_dict = {}
     rootNode = Node(workspace_name)
@@ -192,7 +193,7 @@ def clone_report(
         target_workspace = workspace_name
         target_workspace_id = workspace_id
     else:
-        target_workspace_id = fabric.resolve_workspace_id(target_workspace)
+        target_workspace_id = resolve_workspace_id(workspace=target_workspace)
 
     if target_dataset is not None:
         if target_dataset_workspace is None:

sempy_labs/report/_report_helper.py

@@ -236,15 +236,27 @@ def find_entity_property_pairs(data, result=None, keys_path=None):
         keys_path = []
 
     if isinstance(data, dict):
+        expression = data.get("Expression", {})
+        source_ref = (
+            expression.get("SourceRef", {}) if isinstance(expression, dict) else {}
+        )
+
         if (
-            "Entity" in data.get("Expression", {}).get("SourceRef", {})
+            isinstance(source_ref, dict)
+            and "Entity" in source_ref
             and "Property" in data
         ):
-            entity = data.get("Expression", {}).get("SourceRef", {}).get("Entity", {})
-            property_value = data.get("Property")
-            object_type = keys_path[-1].replace("HierarchyLevel", "Hierarchy")
+            entity = source_ref.get("Entity", "")
+            property_value = data.get("Property", "")
+
+            object_type = (
+                keys_path[-1].replace("HierarchyLevel", "Hierarchy")
+                if keys_path
+                else "Unknown"
+            )
             result[property_value] = (entity, object_type)
-            keys_path.pop()
+            if keys_path:
+                keys_path.pop()
 
         # Recursively search the rest of the dictionary
         for key, value in data.items():

sempy_labs/report/_report_rebind.py

@@ -1,9 +1,9 @@
-import sempy.fabric as fabric
 from sempy_labs._helper_functions import (
     resolve_dataset_id,
     resolve_workspace_name_and_id,
     resolve_report_id,
     _base_api,
+    resolve_dataset_name_and_id,
 )
 from typing import Optional, List
 from sempy._utils._log import log
@@ -104,10 +104,12 @@ def report_rebind_all(
             f"{icons.red_dot} The 'dataset' and 'new_dataset' parameters are both set to '{dataset}'. These parameters must be set to different values."
         )
 
-    dataset_workspace = fabric.resolve_workspace_name(dataset_workspace)
-
-    if new_dataset_workpace is None:
-        new_dataset_workpace = dataset_workspace
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(
+        dataset=dataset, workspace=dataset_workspace
+    )
+    (dataset_workspace_name, dataset_workspace_id) = resolve_workspace_name_and_id(
+        workspace=dataset_workspace
+    )
 
     if isinstance(report_workspace, str):
         report_workspace = [report_workspace]
@@ -118,7 +120,7 @@ def report_rebind_all(
 
     if len(dfR) == 0:
         print(
-            f"{icons.info} The '{dataset}' semantic model within the '{dataset_workspace}' workspace has no dependent reports."
+            f"{icons.info} The '{dataset_name}' semantic model within the '{dataset_workspace_name}' workspace has no dependent reports."
         )
         return