semantic-link-labs 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

sempy_labs/directlake/_directlake_schema_sync.py

@@ -1,24 +1,19 @@
 import sempy
 import sempy.fabric as fabric
-import pandas as pd
-from sempy_labs.lakehouse._get_lakehouse_columns import get_lakehouse_columns
+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
-from sempy_labs._helper_functions import (
-    format_dax_object_name,
-    resolve_lakehouse_name,
-    get_direct_lake_sql_endpoint,
-)
 from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 
+
 @log
 def direct_lake_schema_sync(
     dataset: str,
     workspace: Optional[str] = None,
     add_to_model: Optional[bool] = False,
-    lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None,
+    **kwargs,
 ):
     """
     Shows/adds columns which exist in the lakehouse but do not exist in the semantic model (only for tables in the semantic model).
@@ -33,91 +28,79 @@ 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.
-    lakehouse : str, default=None
-        The Fabric lakehouse used by the Direct Lake semantic model.
-        Defaults to None which resolves to the lakehouse attached to the notebook.
-    lakehouse_workspace : str, default=None
-        The Fabric workspace 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.
     """
 
     sempy.fabric._client._utils._init_analysis_services()
     import Microsoft.AnalysisServices.Tabular as TOM
     import System
 
-    workspace = fabric.resolve_workspace_name(workspace)
-
-    if lakehouse_workspace is None:
-        lakehouse_workspace = workspace
-
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
-
-    sqlEndpointId = get_direct_lake_sql_endpoint(dataset, workspace)
+    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"]
 
-    dfI = fabric.list_items(workspace=lakehouse_workspace, type="SQLEndpoint")
-    dfI_filt = dfI[(dfI["Id"] == sqlEndpointId)]
-
-    if len(dfI_filt) == 0:
-        raise ValueError(f"{icons.red_dot} The SQL Endpoint in the '{dataset}' semantic model in the '{workspace} workspace does not point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace as specified.")
+    workspace = fabric.resolve_workspace_name(workspace)
 
-    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
-    dfP_filt = dfP[dfP["Source Type"] == "Entity"]
-    dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
-    dfC_filt = dfC[dfC["Table Name"].isin(dfP_filt["Table Name"].values)]
-    dfC_filt = pd.merge(
-        dfC_filt, dfP_filt[["Table Name", "Query"]], on="Table Name", how="left"
-    )
-    dfC_filt["Column Object"] = format_dax_object_name(
-        dfC_filt["Query"], dfC_filt["Source"]
+    artifact_type, lakehouse_name, lakehouse_id, lakehouse_workspace_id = (
+        get_direct_lake_source(dataset=dataset, workspace=workspace)
     )
 
-    lc = get_lakehouse_columns(lakehouse, lakehouse_workspace)
-    lc_filt = lc[lc["Table Name"].isin(dfP_filt["Query"].values)]
+    if artifact_type == "Warehouse":
+        raise ValueError(
+            f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
+        )
+    lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace_id)
+
+    if artifact_type == "Warehouse":
+        raise ValueError(
+            f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
+        )
 
-    mapping = {
-        "string": "String",
-        "bigint": "Int64",
-        "int": "Int64",
-        "smallint": "Int64",
-        "boolean": "Boolean",
-        "timestamp": "DateTime",
-        "date": "DateTime",
-        "decimal(38,18)": "Decimal",
-        "double": "Double",
-    }
+    lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)
 
     with connect_semantic_model(
-                dataset=dataset, readonly=False, workspace=workspace
-            ) as tom:
+        dataset=dataset, readonly=False, workspace=workspace
+    ) as tom:
 
-        for i, r in lc_filt.iterrows():
+        for i, r in lc.iterrows():
             lakeTName = r["Table Name"]
             lakeCName = r["Column Name"]
-            fullColName = r["Full Column Name"]
             dType = r["Data Type"]
 
-            if fullColName not in dfC_filt["Column Object"].values:
-                dfL = dfP_filt[dfP_filt["Query"] == lakeTName]
-                tName = dfL["Table Name"].iloc[0]
-                if add_to_model:
-                    col = TOM.DataColumn()
-                    col.Name = lakeCName
-                    col.SourceColumn = lakeCName
-                    dt = mapping.get(dType)
-                    try:
-                        col.DataType = System.Enum.Parse(TOM.DataType, dt)
-                    except Exception as e:
-                        raise ValueError(f"{icons.red_dot} Failed to map '{dType}' data type to the semantic model data types.") from e
-
-                    tom.model.Tables[tName].Columns.Add(col)
-                    print(
-                        f"{icons.green_dot} The '{lakeCName}' column has been added to the '{tName}' table as a '{dt}' data type within the '{dataset}' semantic model within the '{workspace}' workspace."
-                    )
-                else:
+            if any(
+                p.Source.EntityName == lakeTName
+                for p in tom.all_partitions()
+                if p.SourceType == TOM.PartitionSourceType.Entity
+            ):
+                table_name = next(
+                    t.Name
+                    for t in tom.model.Tables
+                    for p in t.Partitions
+                    if p.SourceType == TOM.PartitionSourceType.Entity
+                    and p.Source.EntityName == lakeTName
+                )
+
+                if not any(
+                    c.SourceColumn == lakeCName and c.Parent.Name == table_name
+                    for c in tom.all_columns()
+                ):
                     print(
-                        f"{icons.yellow_dot} The {fullColName} column exists in the lakehouse but not in the '{tName}' table in the '{dataset}' semantic model within the '{workspace}' workspace."
+                        f"{icons.yellow_dot} The '{lakeCName}' column exists in the '{lakeTName}' lakehouse table but not in the '{dataset}' semantic model within the '{workspace}' workspace."
                     )
-            
+                    if add_to_model:
+                        dt = icons.data_type_mapping.get(dType)
+                        tom.add_data_column(
+                            table_name=table_name,
+                            column_name=lakeCName,
+                            source_column=lakeCName,
+                            data_type=System.Enum.Parse(TOM.DataType, dt),
+                        )
+                        print(
+                            f"{icons.green_dot} The '{lakeCName}' column in the '{lakeTName}' lakehouse table was added to the '{dataset}' semantic model within the '{workspace}' workspace."
+                        )

sempy_labs/directlake/_dl_helper.py

@@ -0,0 +1,233 @@
+import sempy.fabric as fabric
+import numpy as np
+import pandas as pd
+from typing import Optional, List, Union, Tuple
+from uuid import UUID
+import sempy_labs._icons as icons
+from sempy._utils._log import log
+from sempy_labs._helper_functions import retry, resolve_dataset_id
+
+
+def check_fallback_reason(
+    dataset: str, workspace: Optional[str] = None
+) -> pd.DataFrame:
+    """
+    Shows the reason a table in a Direct Lake semantic model would fallback to DirectQuery.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    workspace : str, default=None
+        The Fabric workspace name.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        The tables in the semantic model and their fallback reason.
+    """
+
+    workspace = fabric.resolve_workspace_name(workspace)
+
+    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+    dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
+
+    if len(dfP_filt) == 0:
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
+        )
+
+    df = fabric.evaluate_dax(
+        dataset=dataset,
+        workspace=workspace,
+        dax_string="""
+            SELECT [TableName] AS [Table Name],[FallbackReason] AS [FallbackReasonID]
+            FROM $SYSTEM.TMSCHEMA_DELTA_TABLE_METADATA_STORAGES
+            """,
+    )
+
+    value_mapping = {
+        0: "No reason for fallback",
+        1: "This table is not framed",
+        2: "This object is a view in the lakehouse",
+        3: "The table does not exist in the lakehouse",
+        4: "Transient error",
+        5: "Using OLS will result in fallback to DQ",
+        6: "Using RLS will result in fallback to DQ",
+    }
+
+    # Create a new column based on the mapping
+    df["Fallback Reason Detail"] = np.vectorize(value_mapping.get)(
+        df["FallbackReasonID"]
+    )
+
+    return df
+
+
+@log
+def generate_direct_lake_semantic_model(
+    dataset: str,
+    lakehouse_tables: Union[str, List[str]],
+    workspace: Optional[str] = None,
+    lakehouse: Optional[str] = None,
+    lakehouse_workspace: Optional[str] = None,
+    overwrite: Optional[bool] = False,
+    refresh: Optional[bool] = True,
+):
+    """
+    Dynamically generates a Direct Lake semantic model based on tables in a Fabric lakehouse.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model to be created.
+    lakehouse_tables : str | List[str]
+        The table(s) within the Fabric lakehouse to add to the semantic model. All columns from these tables will be added to the semantic model.
+    workspace : str, default=None
+        The Fabric workspace name in which the semantic model will reside.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    lakehouse : str, default=None
+        The lakehouse which stores the delta tables which will feed the Direct Lake semantic model.
+        Defaults to None which resolves to the attached lakehouse.
+    lakehouse_workspace : str, default=None
+        The Fabric workspace in which the 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.
+    overwrite : bool, default=False
+        If set to True, overwrites the existing semantic model if it already exists.
+    refresh: bool, default=True
+        If True, refreshes the newly created semantic model after it is created.
+
+    Returns
+    -------
+    """
+
+    from sempy_labs.lakehouse import get_lakehouse_tables, get_lakehouse_columns
+    from sempy_labs import create_blank_semantic_model, refresh_semantic_model
+    from sempy_labs.tom import connect_semantic_model
+    from sempy_labs.directlake import get_shared_expression
+
+    if isinstance(lakehouse_tables, str):
+        lakehouse_tables = [lakehouse_tables]
+
+    dfLT = get_lakehouse_tables(lakehouse=lakehouse, workspace=lakehouse_workspace)
+
+    # Validate lakehouse tables
+    for t in lakehouse_tables:
+        if t not in dfLT["Table Name"].values:
+            raise ValueError(
+                f"{icons.red_dot} The '{t}' table does not exist as a delta table in the '{lakehouse}' within the '{workspace}' workspace."
+            )
+
+    dfLC = get_lakehouse_columns(lakehouse=lakehouse, workspace=lakehouse_workspace)
+    expr = get_shared_expression(lakehouse=lakehouse, workspace=lakehouse_workspace)
+    dfD = fabric.list_datasets(workspace=workspace)
+    dfD_filt = dfD[dfD["Dataset Name"] == dataset]
+    dfD_filt_len = len(dfD_filt)
+
+    if dfD_filt_len > 0 and overwrite is False:
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace already exists. Overwrite is set to False so the new semantic model has not been created."
+        )
+    if dfD_filt_len > 0 and overwrite:
+        print(
+            f"{icons.warning} Overwriting the existing '{dataset}' semantic model within the '{workspace}' workspace."
+        )
+
+    create_blank_semantic_model(dataset=dataset, workspace=workspace)
+
+    @retry(
+        sleep_time=1,
+        timeout_error_message=f"{icons.red_dot} Function timed out after 1 minute",
+    )
+    def dyn_connect():
+        with connect_semantic_model(
+            dataset=dataset, readonly=True, workspace=workspace
+        ) as tom:
+
+            tom.model
+
+    dyn_connect()
+
+    expression_name = "DatabaseQuery"
+    with connect_semantic_model(
+        dataset=dataset, workspace=workspace, readonly=False
+    ) as tom:
+        if not any(e.Name == expression_name for e in tom.model.Expressions):
+            tom.add_expression(name=expression_name, expression=expr)
+
+        for t in lakehouse_tables:
+            tom.add_table(name=t)
+            tom.add_entity_partition(table_name=t, entity_name=t)
+            dfLC_filt = dfLC[dfLC["Table Name"] == t]
+            for i, r in dfLC_filt.iterrows():
+                lakeCName = r["Column Name"]
+                dType = r["Data Type"]
+                dt = icons.data_type_mapping.get(dType)
+                tom.add_data_column(
+                    table_name=t,
+                    column_name=lakeCName,
+                    source_column=lakeCName,
+                    data_type=dt,
+                )
+
+    if refresh:
+        refresh_semantic_model(dataset=dataset, workspace=workspace)
+
+
+def get_direct_lake_source(
+    dataset: str, workspace: Optional[str] = None
+) -> Tuple[str, str, UUID, UUID]:
+    """
+    Obtains the source information for a direct lake semantic model.
+
+    Parameters
+    ----------
+    dataset : str
+        The name of the semantic model.
+    workspace : str, default=None
+        The Fabric workspace name.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    Tuple[str, str, UUID, UUID]
+        If the source of the direct lake semantic model is a lakehouse this will return: 'Lakehouse', Lakehouse Name, SQL Endpoint Id, Workspace Id
+        If the source of the direct lake semantic model is a warehouse this will return: 'Warehouse', Warehouse Name, Warehouse Id, Workspace Id
+        If the semantic model is not a Direct Lake semantic model, it will return None, None, None.
+    """
+
+    workspace = fabric.resolve_workspace_name(workspace)
+    dataset_id = resolve_dataset_id(dataset, workspace)
+    client = fabric.PowerBIRestClient()
+    request_body = {
+        "artifacts": [
+            {
+                "objectId": dataset_id,
+                "type": "dataset",
+            }
+        ]
+    }
+    response = client.post(
+        "metadata/relations/upstream?apiVersion=3", json=request_body
+    )
+    artifacts = response.json().get("artifacts", [])
+    sql_id, sql_object_name, sql_workspace_id, artifact_type = None, None, None, None
+
+    for artifact in artifacts:
+        object_type = artifact.get("typeName")
+        display_name = artifact.get("displayName")
+        if object_type in ["Datawarehouse", "Lakewarehouse"]:
+            artifact_type = (
+                "Warehouse" if object_type == "Datawarehouse" else "Lakehouse"
+            )
+            sql_id = artifact.get("objectId")
+            sql_workspace_id = artifact.get("workspace", {}).get("objectId")
+            sql_object_name = display_name
+            break
+
+    return artifact_type, sql_object_name, sql_id, sql_workspace_id

sempy_labs/directlake/_get_directlake_lakehouse.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs._helper_functions import (
     resolve_lakehouse_id,
@@ -7,7 +6,7 @@ from sempy_labs._helper_functions import (
 )
 from typing import Optional, Tuple
 from uuid import UUID
-import sempy_labs._icons as icons
+
 
 def get_direct_lake_lakehouse(
     dataset: str,
@@ -49,13 +48,13 @@ def get_direct_lake_lakehouse(
         lakehouse_id = fabric.get_lakehouse_id()
         lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
 
-    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
-    dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
+    # dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+    # dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
 
-    if len(dfP_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode."
-        )
+    # if len(dfP_filt) == 0:
+    #    raise ValueError(
+    #        f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode."
+    #    )
 
     sqlEndpointId = get_direct_lake_sql_endpoint(dataset, workspace)
 

sempy_labs/directlake/_get_shared_expression.py

@@ -1,13 +1,13 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs._helper_functions import resolve_lakehouse_name
 from sempy_labs._list_functions import list_lakehouses
 from typing import Optional
 import sempy_labs._icons as icons
 
+
 def get_shared_expression(
     lakehouse: Optional[str] = None, workspace: Optional[str] = None
-):
+) -> str:
     """
     Dynamically generates the M expression used by a Direct Lake model for a given lakehouse.
 
@@ -40,7 +40,9 @@ def get_shared_expression(
     provStatus = lakeDetail["SQL Endpoint Provisioning Status"].iloc[0]
 
     if provStatus == "InProgress":
-        raise ValueError(f"{icons.red_dot} The SQL Endpoint for the '{lakehouse}' lakehouse within the '{workspace}' workspace has not yet been provisioned. Please wait until it has been provisioned.")
+        raise ValueError(
+            f"{icons.red_dot} The SQL Endpoint for the '{lakehouse}' lakehouse within the '{workspace}' workspace has not yet been provisioned. Please wait until it has been provisioned."
+        )
 
     sh = (
         'let\n\tdatabase = Sql.Database("'

sempy_labs/directlake/_guardrails.py

@@ -1,12 +1,13 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
-from typing import List, Optional, Union
+from typing import Optional
+import sempy_labs._icons as icons
 
 
 def get_direct_lake_guardrails() -> pd.DataFrame:
     """
-    Shows the guardrails for when Direct Lake semantic models will fallback to Direct Query based on Microsoft's `online documentation <https://learn.microsoft.com/power-bi/enterprise/directlake-overview>`_.
+    Shows the guardrails for when Direct Lake semantic models will fallback to Direct Query
+     based on Microsoft's `online documentation <https://learn.microsoft.com/power-bi/enterprise/directlake-overview>`_.
 
     Parameters
     ----------
@@ -27,14 +28,14 @@ def get_direct_lake_guardrails() -> pd.DataFrame:
     return df
 
 
-def get_sku_size(workspace: Optional[str] = None):
+def get_sku_size(workspace: Optional[str] = None) -> str:
     """
     Shows the SKU size for a workspace.
 
     Parameters
     ----------
     workspace : str, default=None
-        The Fabric workspace.
+        The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
 
@@ -46,18 +47,21 @@ def get_sku_size(workspace: Optional[str] = None):
 
     workspace = fabric.resolve_workspace_name(workspace)
 
+    dfW = fabric.list_workspaces(filter=f"name eq '{workspace}'")
+
+    if len(dfW) == 0:
+        raise ValueError(f"{icons.red_dot} The '{workspace}' is not a valid workspace.")
+
+    capacity_id = dfW["Capacity Id"].iloc[0]
     dfC = fabric.list_capacities()
-    dfW = fabric.list_workspaces().sort_values(by="Name", ascending=True)
-    dfC.rename(columns={"Id": "Capacity Id"}, inplace=True)
-    dfCW = pd.merge(
-        dfW,
-        dfC[["Capacity Id", "Sku", "Region", "State"]],
-        on="Capacity Id",
-        how="inner",
-    )
-    sku_value = dfCW.loc[dfCW["Name"] == workspace, "Sku"].iloc[0]
-
-    return sku_value
+    dfC_filt = dfC[dfC["Id"] == capacity_id]
+
+    if len(dfC_filt) == 0:
+        raise ValueError(
+            f"{icons.red_dot} The '{capacity_id}' Id is not a valid capacity Id."
+        )
+
+    return dfC_filt["Sku"].iloc[0]
 
 
 def get_directlake_guardrails_for_sku(sku_size: str) -> pd.DataFrame:

sempy_labs/directlake/_list_directlake_model_calc_tables.py

@@ -1,14 +1,16 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs._list_functions import list_tables, list_annotations
+from sempy_labs._list_functions import list_tables
 from sempy_labs.tom import connect_semantic_model
 from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 
+
 @log
-def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] = None) -> pd.DataFrame:
+def list_direct_lake_model_calc_tables(
+    dataset: str, workspace: Optional[str] = None
+) -> pd.DataFrame:
     """
     Shows the calculated tables and their respective DAX expression for a Direct Lake model (which has been migrated from import/DirectQuery).
 
@@ -32,18 +34,21 @@ def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] =
     df = pd.DataFrame(columns=["Table Name", "Source Expression"])
 
     with connect_semantic_model(
-                dataset=dataset, readonly=True, workspace=workspace
-            ) as tom:
-        
+        dataset=dataset, readonly=True, workspace=workspace
+    ) as tom:
+
         is_direct_lake = tom.is_direct_lake()
 
         if not is_direct_lake:
-            raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode.")
+            raise ValueError(
+                f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake mode."
+            )
         else:
-            dfA = list_annotations(dataset, workspace)
+            dfA = fabric.list_annotations(dataset=dataset, workspace=workspace)
             dfT = list_tables(dataset, workspace)
             dfA_filt = dfA[
-                (dfA["Object Type"] == "Model") & (dfA["Annotation Name"].isin(dfT["Name"]))
+                (dfA["Object Type"] == "Model")
+                & (dfA["Annotation Name"].isin(dfT["Name"]))
             ]
 
             for i, r in dfA_filt.iterrows():
@@ -51,6 +56,8 @@ def list_direct_lake_model_calc_tables(dataset: str, workspace: Optional[str] =
                 se = r["Annotation Value"]
 
                 new_data = {"Table Name": tName, "Source Expression": se}
-                df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
 
             return df

sempy_labs/directlake/_show_unsupported_directlake_objects.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._list_functions import list_tables
@@ -6,12 +5,14 @@ from sempy_labs._helper_functions import format_dax_object_name
 from typing import Optional, Tuple
 from sempy._utils._log import log
 
+
 @log
 def show_unsupported_direct_lake_objects(
     dataset: str, workspace: Optional[str] = None
 ) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
     """
-    Returns a list of a semantic model's objects which are not supported by Direct Lake based on `official documentation <https://learn.microsoft.com/power-bi/enterprise/directlake-overview#known-issues-and-limitations>`_.
+    Returns a list of a semantic model's objects which are not supported by Direct Lake based on
+     `official documentation <https://learn.microsoft.com/power-bi/enterprise/directlake-overview#known-issues-and-limitations>`_.
 
     Parameters
     ----------

sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py

@@ -1,9 +1,7 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs.directlake._get_shared_expression import get_shared_expression
 from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
-    resolve_workspace_name_and_id,
 )
 from sempy_labs.tom import connect_semantic_model
 from typing import Optional
@@ -54,13 +52,18 @@ def update_direct_lake_model_lakehouse_connection(
     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. Therefore it cannot be used to support the '{dataset}' semantic model within the '{workspace}' workspace.")
+        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}' semantic model within the '{workspace}' workspace."
+        )
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
 
     if len(dfP_filt) == 0:
-        raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models.")
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
+        )
     else:
         with connect_semantic_model(
             dataset=dataset, readonly=False, workspace=workspace
@@ -73,4 +76,6 @@ def update_direct_lake_model_lakehouse_connection(
                     f"{icons.green_dot} The expression in the '{dataset}' semantic model has been updated to point to the '{lakehouse}' lakehouse in the '{lakehouse_workspace}' workspace."
                 )
             except Exception as e:
-                raise ValueError(f"{icons.red_dot} The expression in the '{dataset}' semantic model was not updated.") from e
+                raise ValueError(
+                    f"{icons.red_dot} The expression in the '{dataset}' semantic model was not updated."
+                ) from e