semantic-link-labs 0.9.4__py3-none-any.whl → 0.9.6__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/_directlake_schema_compare.py

@@ -4,6 +4,7 @@ from sempy_labs._helper_functions import (
     format_dax_object_name,
     resolve_workspace_name_and_id,
     resolve_dataset_name_and_id,
+    resolve_workspace_name,
 )
 from IPython.display import display
 from sempy_labs.lakehouse import get_lakehouse_columns
@@ -70,7 +71,7 @@ def direct_lake_schema_compare(
             f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
         )
 
-    lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
+    lakehouse_workspace = resolve_workspace_name(workspace_id=lakehouse_workspace_id)
     dfT = fabric.list_tables(dataset=dataset_id, workspace=workspace_id)
     dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id)
     lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)

sempy_labs/directlake/_directlake_schema_sync.py

@@ -1,5 +1,5 @@
 import sempy
-import sempy.fabric as fabric
+import pandas as pd
 from sempy_labs.lakehouse import get_lakehouse_columns
 from sempy_labs.directlake._dl_helper import get_direct_lake_source
 from sempy_labs.tom import connect_semantic_model
@@ -19,8 +19,8 @@ def direct_lake_schema_sync(
     dataset: str | UUID,
     workspace: Optional[str | UUID] = None,
     add_to_model: bool = False,
-    **kwargs,
-):
+    remove_from_model: bool = False,
+) -> pd.DataFrame:
     """
     Shows/adds columns which exist in the lakehouse but do not exist in the semantic model (only for tables in the semantic model).
 
@@ -34,22 +34,18 @@ def direct_lake_schema_sync(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     add_to_model : bool, default=False
         If set to True, columns which exist in the lakehouse but do not exist in the semantic model are added to the semantic model. No new tables are added.
+    remove_from_model : bool, default=False
+        If set to True, columns which exist in the semantic model but do not exist in the lakehouse are removed from the semantic model. No new tables are removed.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing the status of columns in the semantic model and lakehouse (prior to adding/removing them from the model using this function).
     """
 
     sempy.fabric._client._utils._init_analysis_services()
     import Microsoft.AnalysisServices.Tabular as TOM
 
-    if "lakehouse" in kwargs:
-        print(
-            "The 'lakehouse' parameter has been deprecated as it is no longer necessary. Please remove this parameter from the function going forward."
-        )
-        del kwargs["lakehouse"]
-    if "lakehouse_workspace" in kwargs:
-        print(
-            "The 'lakehouse_workspace' parameter has been deprecated as it is no longer necessary. Please remove this parameter from the function going forward."
-        )
-        del kwargs["lakehouse_workspace"]
-
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
@@ -67,14 +63,54 @@ def direct_lake_schema_sync(
             f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
         )
 
-    lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
+    lc = get_lakehouse_columns(lakehouse_id, lakehouse_workspace_id)
 
-    lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)
+    readonly = True
+    if add_to_model or remove_from_model:
+        readonly = False
+    df = pd.DataFrame(
+        columns=[
+            "TableName",
+            "ColumnName",
+            "SourceTableName",
+            "SourceColumnName",
+            "Status",
+        ]
+    )
 
     with connect_semantic_model(
-        dataset=dataset_id, readonly=False, workspace=workspace_id
+        dataset=dataset_id, readonly=readonly, workspace=workspace_id
     ) as tom:
+        # Check if the columns in the semantic model exist in the lakehouse
+        for c in tom.all_columns():
+            partition_name = next(p.Name for p in c.Table.Partitions)
+            p = c.Table.Partitions[partition_name]
+            if p.SourceType == TOM.PartitionSourceType.Entity:
+                entity_name = p.Source.EntityName
+                source_column = c.SourceColumn
+                lc_filt = lc[
+                    (lc["Table Name"] == entity_name)
+                    & (lc["Column Name"] == source_column)
+                ]
+                # Remove column from model if it doesn't exist in the lakehouse
+                if lc_filt.empty:
+                    new_data = {
+                        "TableName": c.Parent.Name,
+                        "ColumnName": c.Name,
+                        "SourceTableName": entity_name,
+                        "SourceColumnName": source_column,
+                        "Status": "Not in lakehouse",
+                    }
+                    df = pd.concat(
+                        [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+                    if remove_from_model:
+                        tom.remove_object(object=c)
+                        print(
+                            f"{icons.green_dot} The '{c.Parent.Name}'[{c.Name}] column has been removed from the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
+                        )
 
+        # Check if the lakehouse columns exist in the semantic model
         for i, r in lc.iterrows():
             lakeTName = r["Table Name"]
             lakeCName = r["Column Name"]
@@ -97,9 +133,17 @@ def direct_lake_schema_sync(
                     c.SourceColumn == lakeCName and c.Parent.Name == table_name
                     for c in tom.all_columns()
                 ):
-                    print(
-                        f"{icons.yellow_dot} The '{lakeCName}' column exists in the '{lakeTName}' lakehouse table but not in the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
+                    new_data = {
+                        "TableName": table_name,
+                        "ColumnName": None,
+                        "SourceTableName": lakeTName,
+                        "SourceColumnName": lakeCName,
+                        "Status": "Not in semantic model",
+                    }
+                    df = pd.concat(
+                        [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
                     )
+
                     if add_to_model:
                         dt = _convert_data_type(dType)
                         tom.add_data_column(
@@ -111,3 +155,5 @@ def direct_lake_schema_sync(
                         print(
                             f"{icons.green_dot} The '{lakeCName}' column in the '{lakeTName}' lakehouse table was added to the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
                         )
+
+        return df

sempy_labs/directlake/_dl_helper.py

@@ -7,7 +7,6 @@ import sempy_labs._icons as icons
 from sempy._utils._log import log
 from sempy_labs._helper_functions import (
     retry,
-    resolve_lakehouse_name,
     _convert_data_type,
     resolve_dataset_name_and_id,
     resolve_workspace_name_and_id,
@@ -129,11 +128,6 @@ def generate_direct_lake_semantic_model(
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     if lakehouse_workspace is None:
         lakehouse_workspace = workspace
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse_workspace_id = fabric.get_workspace_id()
-        lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
-        lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
 
     dfLT = get_lakehouse_tables(lakehouse=lakehouse, workspace=lakehouse_workspace)
 

sempy_labs/directlake/_generate_shared_expression.py

@@ -1,10 +1,8 @@
-import sempy.fabric as fabric
 from sempy_labs._helper_functions import (
-    resolve_lakehouse_name,
-    resolve_lakehouse_id,
-    resolve_warehouse_id,
     resolve_workspace_name_and_id,
     _base_api,
+    resolve_lakehouse_name_and_id,
+    resolve_item_name_and_id,
 )
 from typing import Optional
 import sempy_labs._icons as icons
@@ -45,13 +43,14 @@ def generate_shared_expression(
             f"{icons.red_dot} Invalid item type. Valid options: {item_types}."
         )
 
-    if item_name is None:
-        item_id = fabric.get_lakehouse_id()
-        item_name = resolve_lakehouse_name(item_id, workspace_id)
-    elif item_name is not None and item_type == "Lakehouse":
-        item_id = resolve_lakehouse_id(lakehouse=item_name, workspace=workspace_id)
-    elif item_type == "Warehouse":
-        item_id = resolve_warehouse_id(warehouse=item_name, workspace=workspace_id)
+    if item_type == "Lakehouse":
+        (item_name, item_id) = resolve_lakehouse_name_and_id(
+            lakehouse=item_name, workspace=workspace_id
+        )
+    else:
+        (item_name, item_id) = resolve_item_name_and_id(
+            item=item_name, type=item_type, workspace=workspace_id
+        )
 
     item_type_rest = f"{item_type.lower()}s"
     response = _base_api(

sempy_labs/directlake/_guardrails.py

@@ -48,6 +48,7 @@ def get_sku_size(workspace: Optional[str | UUID] = None) -> str:
     str
         The SKU size for a workspace.
     """
+    from sempy_labs._capacities import list_capacities
 
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
@@ -59,7 +60,7 @@ def get_sku_size(workspace: Optional[str | UUID] = None) -> str:
         )
 
     capacity_id = dfW["Capacity Id"].iloc[0]
-    dfC = fabric.list_capacities()
+    dfC = list_capacities()
     dfC_filt = dfC[dfC["Id"] == capacity_id]
 
     if len(dfC_filt) == 0:

sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py

@@ -4,6 +4,8 @@ from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     resolve_dataset_name_and_id,
     resolve_workspace_name_and_id,
+    resolve_item_name_and_id,
+    resolve_lakehouse_name_and_id,
 )
 from sempy_labs.tom import connect_semantic_model
 from typing import Optional
@@ -40,22 +42,9 @@ def update_direct_lake_model_lakehouse_connection(
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
-    if lakehouse_workspace is None:
-        lakehouse_workspace = workspace_name
-
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
-
-    # Check if lakehouse is valid
-    dfI = fabric.list_items(workspace=lakehouse_workspace, type="Lakehouse")
-    dfI_filt = dfI[(dfI["Display Name"] == lakehouse)]
-
-    if len(dfI_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{lakehouse}' lakehouse does not exist within the '{lakehouse_workspace}' workspace. "
-            f"Therefore it cannot be used to support the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
-        )
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=lakehouse_workspace
+    )
 
     icons.sll_tags.append("UpdateDLConnection")
 
@@ -121,21 +110,19 @@ def update_direct_lake_model_connection(
     if source_workspace is None:
         source_workspace = workspace_name
 
-    if source is None:
-        source_id = fabric.get_lakehouse_id()
-        source = resolve_lakehouse_name(source_id, source_workspace)
-    else:
-        source_id = fabric.resolve_item_id(
-            item_name=source, type=source_type, workspace=source_workspace
+    if source_type == "Lakehouse":
+        (source_name, source_id) = resolve_lakehouse_name_and_id(
+            lakehouse=source, workspace=source_workspace
         )
-        source = fabric.resolve_item_name(
-            item_id=source_id, workspace=source_workspace, type=source_type
+    else:
+        (source_name, source_id) = resolve_item_name_and_id(
+            item=source, type=source_type, workspace=source_workspace
         )
 
     icons.sll_tags.append("UpdateDLConnection")
 
     shEx = generate_shared_expression(
-        item_name=source, item_type=source_type, workspace=source_workspace
+        item_name=source_name, item_type=source_type, workspace=source_workspace
     )
 
     with connect_semantic_model(

sempy_labs/directlake/_update_directlake_partition_entity.py

@@ -1,5 +1,4 @@
 import sempy
-import sempy.fabric as fabric
 from sempy_labs.tom import connect_semantic_model
 from sempy_labs._refresh_semantic_model import refresh_semantic_model
 from sempy_labs.directlake._dl_helper import get_direct_lake_source
@@ -7,6 +6,7 @@ from sempy_labs._helper_functions import (
     _convert_data_type,
     resolve_dataset_name_and_id,
     resolve_workspace_name_and_id,
+    resolve_workspace_name,
 )
 from typing import List, Optional, Union
 import sempy_labs._icons as icons
@@ -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
@@ -79,9 +83,13 @@ def update_direct_lake_partition_entity(
             tom.model.Tables[tName].Partitions[part_name].Source.EntityName = eName
 
             # Update source lineage tag
-            schema = (
+            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."
@@ -136,7 +144,7 @@ def add_table_to_direct_lake_semantic_model(
             f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
         )
 
-    lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
+    lakehouse_workspace = resolve_workspace_name(workspace_id=lakehouse_workspace_id)
 
     with connect_semantic_model(
         dataset=dataset_id, readonly=False, workspace=workspace_id

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