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

sempy_labs/admin/_workspaces.py

@@ -0,0 +1,148 @@
+from sempy_labs._helper_functions import (
+    _base_api,
+    _build_url,
+    _encode_user,
+)
+from uuid import UUID
+from typing import Optional
+from sempy_labs.admin._basic_functions import (
+    _resolve_workspace_name_and_id,
+)
+import sempy_labs._icons as icons
+
+
+def add_user_to_workspace(
+    user: str | UUID,
+    role: str = "Member",
+    principal_type: str = "User",
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Grants user permissions to the specified workspace.
+
+    This is a wrapper function for the following API: `Admin - Groups AddUserAsAdmin <https://learn.microsoft.com/rest/api/power-bi/admin/groups-add-user-as-admin>`_.
+
+    Parameters
+    ----------
+    user : str | uuid.UUID
+        The user identifier or email address. For service principals and groups you must use the user identifier.
+    role : str, default="Member"
+        The role of the user in the workspace. Options are: 'Admin', 'Contributor', 'Member', 'None', 'Viewer'.
+    principal_type : str, default="User"
+        The principal type of the user. Options are: 'App', 'Group', 'None', 'User'.
+    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.
+    """
+
+    (workspace_name, workspace_id) = _resolve_workspace_name_and_id(workspace)
+
+    # Validation
+    role = role.capitalize()
+    roles = ["Admin", "Contributor", "Member", "None", "Viewer"]
+    if role not in roles:
+        raise ValueError(f"{icons.red_dot} Invalid role. Please choose from {roles}")
+    principal_types = ["App", "Group", "None", "User"]
+    if principal_type not in principal_types:
+        raise ValueError(
+            f"{icons.red_dot} Invalid principal type. Please choose from {principal_types}"
+        )
+
+    user = _encode_user(user)
+
+    payload = {
+        "identifier": user,  # identifier or emailAddress?
+        "principalType": principal_type,
+        "groupUserAccessRight": role,
+    }
+
+    _base_api(
+        request=f"/v1.0/myorg/admin/groups/{workspace_id}/users",
+        method="post",
+        payload=payload,
+    )
+
+    print(
+        f"{icons.green_dot} The '{user}' user has been added with '{role.lower()}' permissions to the '{workspace_name}' workspace."
+    )
+
+
+def delete_user_from_workspace(
+    user: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    is_group: Optional[bool] = None,
+    profile_id: Optional[str] = None,
+):
+    """
+    Removes user permissions from the specified workspace.
+
+    This is a wrapper function for the following API: `Admin - Groups DeleteUserAsAdmin <https://learn.microsoft.com/rest/api/power-bi/admin/groups-delete-user-as-admin>`_.
+
+    Parameters
+    ----------
+    user : str | uuid.UUID
+        The user identifier or email address. For service principals and groups you must use the user identifier.
+    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.
+    is_group : bool, default=None
+        Whether a given user is a group or not. This parameter is required when user to delete is group.
+    profile_id : str, default=None
+        The service principal profile ID to delete.
+    """
+
+    (workspace_name, workspace_id) = _resolve_workspace_name_and_id(workspace)
+
+    user = _encode_user(user)
+    url = f"/v1.0/myorg/admin/groups/{workspace_id}/users/{user}"
+
+    params = {}
+    if profile_id is not None:
+        params["profileId"] = profile_id
+    if is_group is not None:
+        params["isGroup"] = is_group
+
+    url = _build_url(url, params)
+
+    _base_api(
+        request=url,
+        method="delete",
+    )
+
+    print(
+        f"{icons.green_dot} The '{user}' user has been removed from the '{workspace_name}' workspace."
+    )
+
+
+def restore_deleted_workspace(workspace_id: UUID, name: str, email_address: str):
+    """
+    Restores a deleted workspace.
+
+    This is a wrapper function for the following API: `Admin - Groups RestoreDeletedGroupAsAdmin <https://learn.microsoft.com/rest/api/power-bi/admin/groups-restore-deleted-group-as-admin>`_.
+
+    Parameters
+    ----------
+    workspace_id : uuid.UUID
+        The ID of the workspace to restore.
+    name : str
+        The name of the group to be restored
+    email_address : str
+        The email address of the owner of the group to be restored
+    """
+
+    payload = {
+        "name": name,
+        "emailAddress": email_address,
+    }
+
+    _base_api(
+        request=f"/v1.0/myorg/admin/groups/{workspace_id}/restore",
+        method="post",
+        payload=payload,
+    )
+
+    print(
+        f"{icons.green_dot} The '{workspace_id}' workspace has been restored as '{name}'."
+    )

sempy_labs/directlake/_dl_helper.py

@@ -11,7 +11,6 @@ from sempy_labs._helper_functions import (
     _convert_data_type,
     resolve_dataset_name_and_id,
     resolve_workspace_name_and_id,
-    _base_api,
 )
 
 

sempy_labs/directlake/_update_directlake_partition_entity.py

@@ -17,6 +17,7 @@ def update_direct_lake_partition_entity(
     dataset: str | UUID,
     table_name: Union[str, List[str]],
     entity_name: Union[str, List[str]],
+    schema: Optional[str] = None,
     workspace: Optional[str | UUID] = None,
 ):
     """
@@ -30,6 +31,9 @@ def update_direct_lake_partition_entity(
         Name of the table(s) in the semantic model.
     entity_name : str, List[str]
         Name of the lakehouse table to be mapped to the semantic model table.
+    schema : str, default=None
+        The schema of the lakehouse table to be mapped to the semantic model table.
+        Defaults to None which resolves to the existing schema of the lakehouse table.
     workspace : str | uuid.UUID, default=None
         The Fabric workspace name or ID in which the semantic model exists.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -77,6 +81,16 @@ def update_direct_lake_partition_entity(
                 )
 
             tom.model.Tables[tName].Partitions[part_name].Source.EntityName = eName
+
+            # Update source lineage tag
+            existing_schema = (
+                tom.model.Tables[tName].Partitions[part_name].Source.SchemaName or "dbo"
+            )
+            if schema is None:
+                schema = existing_schema
+
+            tom.model.Tables[tName].Partitions[part_name].Source.SchemaName = schema
+            tom.model.Tables[tName].SourceLineageTag = f"[{schema}].[{eName}]"
             print(
                 f"{icons.green_dot} The '{tName}' table in the '{dataset_name}' semantic model within the '{workspace_name}' workspace has been updated to point to the '{eName}' table."
             )

sempy_labs/graph/_teams.py

@@ -35,7 +35,7 @@ def list_teams() -> pd.DataFrame:
         "Archived": "bool",
         "Favorite By Me": "bool",
         "Discoverable By Me": "bool",
-        "Member Count": "int",
+        "Member Count": "int_fillna",
     }
 
     df = _create_dataframe(columns=columns)

sempy_labs/graph/_users.py

@@ -125,6 +125,7 @@ def send_mail(
     subject: str,
     to_recipients: str | List[str],
     content: str,
+    content_type: str = "Text",
     cc_recipients: str | List[str] = None,
 ):
     """
@@ -144,10 +145,17 @@ def send_mail(
         The email address of the recipients.
     content : str
         The email content.
+    content_type : str, default="Text"
+        The email content type. Options: "Text" or "HTML".
     cc_recipients : str | List[str], default=None
         The email address of the CC recipients.
     """
 
+    if content_type.lower() == "html":
+        content_type = "HTML"
+    else:
+        content_type = "Text"
+
     user_id = resolve_user_id(user=user)
 
     if isinstance(to_recipients, str):
@@ -170,7 +178,7 @@ def send_mail(
         "message": {
             "subject": subject,
             "body": {
-                "contentType": "Text",
+                "contentType": content_type,
                 "content": content,
             },
             "toRecipients": to_email_addresses,

sempy_labs/lakehouse/__init__.py

@@ -12,6 +12,7 @@ from sempy_labs.lakehouse._shortcuts import (
     create_shortcut_onelake,
     delete_shortcut,
     reset_shortcut_cache,
+    list_shortcuts,
 )
 
 __all__ = [
@@ -25,4 +26,5 @@ __all__ = [
     "vacuum_lakehouse_tables",
     "reset_shortcut_cache",
     "run_table_maintenance",
+    "list_shortcuts",
 ]

sempy_labs/lakehouse/_lakehouse.py

@@ -35,7 +35,7 @@ def lakehouse_attached() -> bool:
 @log
 def optimize_lakehouse_tables(
     tables: Optional[Union[str, List[str]]] = None,
-    lakehouse: Optional[str] = None,
+    lakehouse: Optional[str | UUID] = None,
     workspace: Optional[str | UUID] = None,
 ):
     """
@@ -46,8 +46,8 @@ def optimize_lakehouse_tables(
     tables : str | List[str], default=None
         The table(s) to optimize.
         Defaults to None which resovles to optimizing all tables within the lakehouse.
-    lakehouse : str, default=None
-        The Fabric lakehouse.
+    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.
@@ -82,7 +82,7 @@ def optimize_lakehouse_tables(
 @log
 def vacuum_lakehouse_tables(
     tables: Optional[Union[str, List[str]]] = None,
-    lakehouse: Optional[str] = None,
+    lakehouse: Optional[str | UUID] = None,
     workspace: Optional[str | UUID] = None,
     retain_n_hours: Optional[int] = None,
 ):
@@ -93,8 +93,8 @@ def vacuum_lakehouse_tables(
     ----------
     tables : str | List[str] | None
         The table(s) to vacuum. If no tables are specified, all tables in the lakehouse will be optimized.
-    lakehouse : str, default=None
-        The Fabric lakehouse.
+    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.
@@ -107,7 +107,6 @@ def vacuum_lakehouse_tables(
         The default retention period is 168 hours (7 days) unless manually configured via table properties.
     """
 
-    from pyspark.sql import SparkSession
     from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
     from delta import DeltaTable
 

sempy_labs/lakehouse/_shortcuts.py

@@ -1,16 +1,19 @@
 import sempy.fabric as fabric
+import pandas as pd
 from sempy_labs._helper_functions import (
-    resolve_lakehouse_name,
-    resolve_lakehouse_id,
+    resolve_lakehouse_name_and_id,
     resolve_workspace_name_and_id,
     _base_api,
+    _create_dataframe,
 )
+from sempy._utils._log import log
 from typing import Optional
 import sempy_labs._icons as icons
-from sempy.fabric.exceptions import FabricHTTPException
 from uuid import UUID
+from sempy.fabric.exceptions import FabricHTTPException
 
 
+@log
 def create_shortcut_onelake(
     table_name: str,
     source_lakehouse: str,
@@ -18,6 +21,8 @@ def create_shortcut_onelake(
     destination_lakehouse: str,
     destination_workspace: Optional[str | UUID] = None,
     shortcut_name: Optional[str] = None,
+    source_path: str = "Tables",
+    destination_path: str = "Tables",
 ):
     """
     Creates a `shortcut <https://learn.microsoft.com/fabric/onelake/onelake-shortcuts>`_ to a delta table in OneLake.
@@ -40,52 +45,78 @@ def create_shortcut_onelake(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     shortcut_name : str, default=None
         The name of the shortcut 'table' to be created. This defaults to the 'table_name' parameter value.
+    source_path : str, default="Tables"
+        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.
     """
 
+    if not (source_path.startswith("Files") or source_path.startswith("Tables")):
+        raise ValueError(
+            f"{icons.red_dot} The 'source_path' parameter must be either 'Files' or 'Tables'."
+        )
+    if not (
+        destination_path.startswith("Files") or destination_path.startswith("Tables")
+    ):
+        raise ValueError(
+            f"{icons.red_dot} The 'destination_path' parameter must be either 'Files' or 'Tables'."
+        )
+
     (source_workspace_name, source_workspace_id) = resolve_workspace_name_and_id(
         source_workspace
     )
-    source_lakehouse_id = resolve_lakehouse_id(source_lakehouse, source_workspace_id)
-    source_lakehouse_name = fabric.resolve_item_name(
-        item_id=source_lakehouse_id, type="Lakehouse", workspace=source_workspace_id
-    )
 
-    if destination_workspace is None:
-        destination_workspace_name = source_workspace_name
-        destination_workspace_id = source_workspace_id
-    else:
-        destination_workspace_name = destination_workspace
-        destination_workspace_id = fabric.resolve_workspace_id(
-            destination_workspace_name
-        )
+    (source_lakehouse_name, source_lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=source_lakehouse, workspace=source_workspace_id
+    )
 
-    destination_workspace_id = fabric.resolve_workspace_id(destination_workspace)
-    destination_lakehouse_id = resolve_lakehouse_id(
-        destination_lakehouse, destination_workspace
+    (destination_workspace_name, destination_workspace_id) = (
+        resolve_workspace_name_and_id(destination_workspace)
     )
-    destination_lakehouse_name = fabric.resolve_item_name(
-        item_id=destination_lakehouse_id,
-        type="Lakehouse",
-        workspace=destination_workspace_id,
+    (destination_lakehouse_name, destination_lakehouse_id) = (
+        resolve_lakehouse_name_and_id(
+            lakehouse=destination_lakehouse, workspace=destination_workspace_id
+        )
     )
 
     if shortcut_name is None:
         shortcut_name = table_name
 
-    table_path = f"Tables/{table_name}"
+    source_full_path = f"{source_path}/{table_name}"
+
+    actual_shortcut_name = shortcut_name.replace(" ", "")
 
     payload = {
-        "path": "Tables",
-        "name": shortcut_name.replace(" ", ""),
+        "path": destination_path,
+        "name": actual_shortcut_name,
         "target": {
             "oneLake": {
-                "workspaceId": source_workspace_id,
                 "itemId": source_lakehouse_id,
-                "path": table_path,
+                "path": source_full_path,
+                "workspaceId": source_workspace_id,
             }
         },
     }
 
+    # 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}"
+        )
+        response_json = response.json()
+        del response_json["target"]["type"]
+        if response_json.get("target") == payload.get("target"):
+            print(
+                f"{icons.info} The '{actual_shortcut_name}' shortcut already exists in the '{destination_lakehouse_name}' lakehouse within the '{destination_workspace_name}' workspace."
+            )
+            return
+        else:
+            raise ValueError(
+                f"{icons.red_dot} The '{actual_shortcut_name}' shortcut already exists in the '{destination_lakehouse_name} lakehouse within the '{destination_workspace_name}' workspace but has a different source."
+            )
+    except FabricHTTPException:
+        pass
+
     _base_api(
         request=f"/v1/workspaces/{destination_workspace_id}/items/{destination_lakehouse_id}/shortcuts",
         payload=payload,
@@ -94,7 +125,7 @@ def create_shortcut_onelake(
     )
 
     print(
-        f"{icons.green_dot} The shortcut '{shortcut_name}' was created in the '{destination_lakehouse_name}' lakehouse within the '{destination_workspace_name} workspace. It is based on the '{table_name}' table in the '{source_lakehouse_name}' lakehouse within the '{source_workspace_name}' workspace."
+        f"{icons.green_dot} The shortcut '{shortcut_name}' was created in the '{destination_lakehouse_name}' lakehouse within the '{destination_workspace_name}' workspace. It is based on the '{table_name}' table in the '{source_lakehouse_name}' lakehouse within the '{source_workspace_name}' workspace."
     )
 
 
@@ -136,17 +167,14 @@ def create_shortcut(
 
     sourceTitle = source_titles[source]
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-    else:
-        lakehouse_id = resolve_lakehouse_id(lakehouse, workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
 
-    client = fabric.FabricRestClient()
     shortcutActualName = shortcut_name.replace(" ", "")
 
-    request_body = {
+    payload = {
         "path": "Tables",
         "name": shortcutActualName,
         "target": {
@@ -158,26 +186,21 @@ def create_shortcut(
         },
     }
 
-    try:
-        response = client.post(
-            f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts",
-            json=request_body,
-        )
-        if response.status_code == 201:
-            print(
-                f"{icons.green_dot} The shortcut '{shortcutActualName}' was created in the '{lakehouse}' lakehouse within"
-                f" the '{workspace} workspace. It is based on the '{subpath}' table in '{sourceTitle}'."
-            )
-        else:
-            print(response.status_code)
-    except Exception as e:
-        raise ValueError(
-            f"{icons.red_dot} Failed to create a shortcut for the '{shortcut_name}' table."
-        ) from e
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts",
+        method="post",
+        payload=payload,
+        status_codes=201,
+    )
+    print(
+        f"{icons.green_dot} The shortcut '{shortcutActualName}' was created in the '{lakehouse_name}' lakehouse within"
+        f" the '{workspace_name}' workspace. It is based on the '{subpath}' table in '{sourceTitle}'."
+    )
 
 
 def delete_shortcut(
     shortcut_name: str,
+    shortcut_path: str = "Tables",
     lakehouse: Optional[str] = None,
     workspace: Optional[str | UUID] = None,
 ):
@@ -190,7 +213,9 @@ def delete_shortcut(
     ----------
     shortcut_name : str
         The name of the shortcut.
-    lakehouse : str, default=None
+    shortcut_path : str = "Tables"
+        The path of the shortcut to be deleted. Must start with either "Files" or "Tables". Examples: Tables/FolderName/SubFolderName; Files/FolderName/SubFolderName.
+    lakehouse : str | uuid.UUID, default=None
         The Fabric lakehouse name in which the shortcut resides.
         Defaults to None which resolves to the lakehouse attached to the notebook.
     workspace : str | UUID, default=None
@@ -200,20 +225,15 @@ def delete_shortcut(
     """
 
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
 
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, workspace_id)
-    else:
-        lakehouse_id = resolve_lakehouse_id(lakehouse, workspace_id)
-
-    client = fabric.FabricRestClient()
-    response = client.delete(
-        f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts/Tables/{shortcut_name}"
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts/{shortcut_path}/{shortcut_name}",
+        method="delete",
     )
 
-    if response.status_code != 200:
-        raise FabricHTTPException(response)
     print(
         f"{icons.green_dot} The '{shortcut_name}' shortcut in the '{lakehouse}' within the '{workspace_name}' workspace has been deleted."
     )
@@ -245,3 +265,135 @@ def reset_shortcut_cache(workspace: Optional[str | UUID] = None):
     print(
         f"{icons.green_dot} The shortcut cache has been reset for the '{workspace_name}' workspace."
     )
+
+
+@log
+def list_shortcuts(
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+    path: Optional[str] = None,
+) -> pd.DataFrame:
+    """
+    Shows all shortcuts which exist in a Fabric lakehouse and their properties.
+
+    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 name or ID of the Fabric workspace in which lakehouse 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.
+    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.
+        Defaults to None which will retun all shortcuts on the given lakehouse
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing all the shortcuts which exist in the specified lakehouse.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
+
+    columns = {
+        "Shortcut Name": "string",
+        "Shortcut Path": "string",
+        "Source Type": "string",
+        "Source Workspace Id": "string",
+        "Source Workspace Name": "string",
+        "Source Item Id": "string",
+        "Source Item Name": "string",
+        "Source Item Type": "string",
+        "OneLake Path": "string",
+        "Connection Id": "string",
+        "Location": "string",
+        "Bucket": "string",
+        "SubPath": "string",
+        "Source Properties Raw": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    # To improve performance create a dataframe to cache all items for a given workspace
+    itm_clms = {
+        "Id": "string",
+        "Display Name": "string",
+        "Description": "string",
+        "Type": "string",
+        "Workspace Id": "string",
+    }
+    source_items_df = _create_dataframe(columns=itm_clms)
+
+    url = f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts"
+
+    if path is not None:
+        url += f"?parentPath={path}"
+
+    responses = _base_api(
+        request=url,
+        uses_pagination=True,
+    )
+
+    sources = {
+        "AdlsGen2": "adlsGen2",
+        "AmazonS3": "amazonS3",
+        "Dataverse": "dataverse",
+        "ExternalDataShare": "externalDataShare",
+        "GoogleCloudStorage": "googleCloudStorage",
+        "OneLake": "oneLake",
+        "S3Compatible": "s3Compatible",
+    }
+
+    for r in responses:
+        for i in r.get("value", []):
+            tgt = i.get("target", {})
+            tgt_type = tgt.get("type")
+            connection_id = tgt.get(sources.get(tgt_type), {}).get("connectionId")
+            location = tgt.get(sources.get(tgt_type), {}).get("location")
+            sub_path = tgt.get(sources.get(tgt_type), {}).get("subpath")
+            source_workspace_id = tgt.get(sources.get(tgt_type), {}).get("workspaceId")
+            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)
+                if source_workspace_id is not None
+                else None
+            )
+            # Cache and use it to getitem type and name
+            source_item_type = None
+            source_item_name = None
+            dfI = source_items_df[
+                source_items_df["Workspace Id"] == source_workspace_id
+            ]
+            if dfI.empty:
+                dfI = fabric.list_items(workspace=source_workspace_id)
+                source_items_df = pd.concat([source_items_df, dfI], ignore_index=True)
+
+            dfI_filt = dfI[dfI["Id"] == source_item_id]
+            if not dfI_filt.empty:
+                source_item_type = dfI_filt["Type"].iloc[0]
+                source_item_name = dfI_filt["Display Name"].iloc[0]
+
+            new_data = {
+                "Shortcut Name": i.get("name"),
+                "Shortcut Path": i.get("path"),
+                "Source Type": tgt_type,
+                "Source Workspace Id": source_workspace_id,
+                "Source Workspace Name": source_workspace_name,
+                "Source Item Id": source_item_id,
+                "Source Item Name": source_item_name,
+                "Source Item Type": source_item_type,
+                "OneLake Path": tgt.get(sources.get("oneLake"), {}).get("path"),
+                "Connection Id": connection_id,
+                "Location": location,
+                "Bucket": bucket,
+                "SubPath": sub_path,
+                "Source Properties Raw": str(tgt),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    return df