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

sempy_labs/_model_dependencies.py

@@ -1,12 +1,16 @@
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._helper_functions import format_dax_object_name
+import sempy_labs._icons as icons
 from typing import Any, Dict, Optional
 from anytree import Node, RenderTree
 from sempy._utils._log import log
 
+
 @log
-def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
+def get_measure_dependencies(
+    dataset: str, workspace: Optional[str] = None
+) -> pd.DataFrame:
     """
     Shows all dependencies for all measures in a semantic model.
 
@@ -31,7 +35,7 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
         dataset=dataset,
         workspace=workspace,
         dax_string="""
-        SELECT 
+        SELECT
          [TABLE] AS [Table Name]
         ,[OBJECT] AS [Object Name]
         ,[OBJECT_TYPE] AS [Object Type]
@@ -106,9 +110,9 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
                                             "Table Name": r["Table Name"],
                                             "Object Name": r["Object Name"],
                                             "Object Type": r["Object Type"],
-                                            "Referenced Object": dependency[5],
-                                            "Referenced Table": dependency[4],
-                                            "Referenced Object Type": dependency[6],
+                                            "Referenced Object": dependency[4],
+                                            "Referenced Table": dependency[3],
+                                            "Referenced Object Type": dependency[5],
                                             "Done": d,
                                             "Full Object Name": r["Full Object Name"],
                                             "Referenced Full Object Name": dependency[
@@ -128,8 +132,11 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
 
     return df
 
+
 @log
-def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
+def get_model_calc_dependencies(
+    dataset: str, workspace: Optional[str] = None
+) -> pd.DataFrame:
     """
     Shows all dependencies for all objects in a semantic model.
 
@@ -162,7 +169,7 @@ def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
         ,[REFERENCED_TABLE] AS [Referenced Table]
         ,[REFERENCED_OBJECT] AS [Referenced Object]
         ,[REFERENCED_OBJECT_TYPE] AS [Referenced Object Type]
-        FROM $SYSTEM.DISCOVER_CALC_DEPENDENCY        
+        FROM $SYSTEM.DISCOVER_CALC_DEPENDENCY
         """,
     )
 
@@ -285,7 +292,7 @@ def measure_dependency_tree(
 
     if len(dfM_filt) == 0:
         print(
-            f"The '{measure_name}' measure does not exist in the '{dataset}' semantic model in the '{workspace}' workspace."
+            f"{icons.red_dot} The '{measure_name}' measure does not exist in the '{dataset}' semantic model in the '{workspace}' workspace."
         )
         return
 
@@ -294,9 +301,6 @@ def measure_dependency_tree(
 
     # Create a dictionary to hold references to nodes
     node_dict: Dict[str, Any] = {}
-    measureIcon = "\u2211"
-    tableIcon = "\u229E"
-    columnIcon = "\u229F"
 
     # Populate the tree
     for _, row in df_filt.iterrows():
@@ -311,24 +315,24 @@ def measure_dependency_tree(
         if parent_node is None:
             parent_node = Node(parent_node_name)
             node_dict[parent_node_name] = parent_node
-        parent_node.custom_property = measureIcon + " "
+        parent_node.custom_property = f"{icons.measure_icon} "
 
         # Create the child node
         child_node_name = ref_obj_name
         child_node = Node(child_node_name, parent=parent_node)
         if ref_obj_type == "Column":
-            child_node.custom_property = columnIcon + " '" + ref_obj_table_name + "'"
+            child_node.custom_property = f"{icons.column_icon} '{ref_obj_table_name}'"
         elif ref_obj_type == "Table":
-            child_node.custom_property = tableIcon + " "
+            child_node.custom_property = f"{icons.table_icon} "
         elif ref_obj_type == "Measure":
-            child_node.custom_property = measureIcon + " "
+            child_node.custom_property = f"{icons.measure_icon} "
 
         # Update the dictionary with the child node
         node_dict[child_node_name] = child_node
 
     # Visualize the tree structure using RenderTree
     for pre, _, node in RenderTree(node_dict[measure_name]):
-        if tableIcon in node.custom_property:
+        if icons.table_icon in node.custom_property:
             print(f"{pre}{node.custom_property}'{node.name}'")
         else:
             print(f"{pre}{node.custom_property}[{node.name}]")

sempy_labs/_one_lake_integration.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from typing import Optional
@@ -6,6 +5,7 @@ from sempy._utils._log import log
 from sempy_labs._helper_functions import resolve_workspace_name_and_id
 import sempy_labs._icons as icons
 
+
 @log
 def export_model_to_onelake(
     dataset: str,
@@ -42,19 +42,21 @@ def export_model_to_onelake(
     dfD_filt = dfD[dfD["Dataset Name"] == dataset]
 
     if len(dfD_filt) == 0:
-        raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model does not exist in the '{workspace}' workspace.")
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset}' semantic model does not exist in the '{workspace}' workspace."
+        )
 
     tmsl = f"""
     {{
     'export': {{
     'layout': 'delta',
-    'type': 'full',  
-    'objects': [  
-        {{  
+    'type': 'full',
+    'objects': [
+        {{
         'database': '{dataset}'
-        }}  
-    ]  
-    }}  
+        }}
+    ]
+    }}
     }}
     """
 
@@ -65,8 +67,10 @@ def export_model_to_onelake(
             f"{icons.green_dot} The '{dataset}' semantic model's tables have been exported as delta tables to the '{workspace}' workspace.\n"
         )
     except Exception as e:
-        raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model's tables have not been exported as delta tables to the '{workspace}' workspace.\nMake sure you enable OneLake integration for the '{dataset}' semantic model. Follow the instructions here: https://learn.microsoft.com/power-bi/enterprise/onelake-integration-overview#enable-onelake-integration") from e
-        
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset}' semantic model's tables have not been exported as delta tables to the '{workspace}' workspace.\nMake sure you enable OneLake integration for the '{dataset}' semantic model. Follow the instructions here: https://learn.microsoft.com/power-bi/enterprise/onelake-integration-overview#enable-onelake-integration"
+        ) from e
+
     # Create shortcuts if destination lakehouse is specified
     if destination_lakehouse is not None:
         # Destination...
@@ -116,7 +120,7 @@ def export_model_to_onelake(
 
         print(f"{icons.in_progress} Creating shortcuts...\n")
         for tableName in tables:
-            tablePath = "Tables/" + tableName
+            tablePath = f"Tables/{tableName}"
             shortcutName = tableName.replace(" ", "")
             request_body = {
                 "path": "Tables",
@@ -142,4 +146,6 @@ def export_model_to_onelake(
                 else:
                     print(response.status_code)
             except Exception as e:
-                raise ValueError(f"{icons.red_dot} Failed to create a shortcut for the '{tableName}' table.") from e
+                raise ValueError(
+                    f"{icons.red_dot} Failed to create a shortcut for the '{tableName}' table."
+                ) from e

sempy_labs/_query_scale_out.py

@@ -1,9 +1,12 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs._helper_functions import resolve_dataset_id
-from typing import Optional
+from sempy_labs._helper_functions import (
+    resolve_dataset_id,
+    resolve_workspace_name_and_id,
+)
+from typing import Optional, Tuple
 import sempy_labs._icons as icons
+from sempy.fabric.exceptions import FabricHTTPException
 
 
 def qso_sync(dataset: str, workspace: Optional[str] = None):
@@ -26,12 +29,7 @@ def qso_sync(dataset: str, workspace: Optional[str] = None):
 
     # https://learn.microsoft.com/en-us/rest/api/power-bi/datasets/trigger-query-scale-out-sync-in-group
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
-
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
     dataset_id = resolve_dataset_id(dataset, workspace)
 
     client = fabric.PowerBIRestClient()
@@ -39,14 +37,16 @@ def qso_sync(dataset: str, workspace: Optional[str] = None):
         f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}/queryScaleOut/sync"
     )
 
-    if response.status_code == 200:
-        print(
-            f"{icons.green_dot} QSO sync initiated for the '{dataset}' semantic model within the '{workspace}' workspace."
-        )
-    else:
-        raise ValueError(f"{icons.red_dot} QSO sync failed for the '{dataset}' semantic model within the '{workspace}' workspace.")
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+    print(
+        f"{icons.green_dot} QSO sync initiated for the '{dataset}' semantic model within the '{workspace}' workspace."
+    )
+
 
-def qso_sync_status(dataset: str, workspace: Optional[str] = None):
+def qso_sync_status(
+    dataset: str, workspace: Optional[str] = None
+) -> Tuple[pd.DataFrame, pd.DataFrame]:
     """
     Returns the query scale-out sync status for the specified dataset from the specified workspace.
 
@@ -61,6 +61,8 @@ def qso_sync_status(dataset: str, workspace: Optional[str] = None):
 
     Returns
     -------
+    Tuple[pandas.DataFrame, pandas.DataFrame]
+        2 pandas dataframes showing the query scale-out sync status.
 
     """
 
@@ -84,12 +86,7 @@ def qso_sync_status(dataset: str, workspace: Optional[str] = None):
         columns=["Replica ID", "Replica Type", "Replica Version", "Replica Timestamp"]
     )
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
-
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
     dataset_id = resolve_dataset_id(dataset, workspace)
 
     client = fabric.PowerBIRestClient()
@@ -97,57 +94,57 @@ def qso_sync_status(dataset: str, workspace: Optional[str] = None):
         f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}/queryScaleOut/syncStatus"
     )
 
-    if response.status_code == 200:
-        o = response.json()
-        sos = o["scaleOutStatus"]
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    o = response.json()
+    sos = o.get("scaleOutStatus")
+
+    if sos == "Enabled":
+        new_data = {
+            "Scale Out Status": o.get("scaleOutStatus"),
+            "Sync Start Time": o.get("syncStartTime"),
+            "Sync End Time": o.get("syncEndTime"),
+            "Commit Version": o.get("commitVersion"),
+            "Commit Timestamp": o.get("commitTimestamp"),
+            "Target Sync Version": o.get("targetSyncVersion"),
+            "Target Sync Timestamp": o.get("targetSyncTimestamp"),
+            "Trigger Reason": o.get("triggerReason"),
+            "Min Active Read Version": o.get("minActiveReadVersion"),
+            "Min Active Read Timestamp": o.get("minActiveReadTimestamp"),
+        }
+        df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
-        if sos == "Enabled":
+        for r in o.get("scaleOutReplicas", []):
             new_data = {
-                "Scale Out Status": o["scaleOutStatus"],
-                "Sync Start Time": o["syncStartTime"],
-                "Sync End Time": o["syncEndTime"],
-                "Commit Version": o["commitVersion"],
-                "Commit Timestamp": o["commitTimestamp"],
-                "Target Sync Version": o["targetSyncVersion"],
-                "Target Sync Timestamp": o["targetSyncTimestamp"],
-                "Trigger Reason": o["triggerReason"],
-                "Min Active Read Version": o["minActiveReadVersion"],
-                "Min Active Read Timestamp": o["minActiveReadTimestamp"],
+                "Replica ID": r.get("replicaId"),
+                "Replica Type": r.get("replicaType"),
+                "Replica Version": str(r.get("replicaVersion")),
+                "Replica Timestamp": r.get("replicaTimestamp"),
             }
-            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-            for r in o["scaleOutReplicas"]:
-                new_data = {
-                    "Replica ID": r["replicaId"],
-                    "Replica Type": r["replicaType"],
-                    "Replica Version": str(r["replicaVersion"]),
-                    "Replica Timestamp": r["replicaTimestamp"],
-                }
-                dfRep = pd.concat(
-                    [dfRep, pd.DataFrame(new_data, index=[0])], ignore_index=True
-                )
-
-            df["Sync Start Time"] = pd.to_datetime(df["Sync Start Time"])
-            df["Sync End Time"] = pd.to_datetime(df["Sync End Time"])
-            df["Commit Timestamp"] = pd.to_datetime(df["Commit Timestamp"])
-            df["Target Sync Timestamp"] = pd.to_datetime(df["Target Sync Timestamp"])
-            df["Min Active Read Timestamp"] = pd.to_datetime(
-                df["Min Active Read Timestamp"]
+            dfRep = pd.concat(
+                [dfRep, pd.DataFrame(new_data, index=[0])], ignore_index=True
             )
-            dfRep["Replica Timestamp"] = pd.to_datetime(dfRep["Replica Timestamp"])
-            df["Commit Version"] = df["Commit Version"].astype("int")
-            df["Target Sync Version"] = df["Target Sync Version"].astype("int")
-            df["Min Active Read Version"] = df["Min Active Read Version"].astype("int")
 
-            return df, dfRep
-        else:
-            print(f"{sos}\n\n")
-            return df, dfRep
+        df["Sync Start Time"] = pd.to_datetime(df["Sync Start Time"])
+        df["Sync End Time"] = pd.to_datetime(df["Sync End Time"])
+        df["Commit Timestamp"] = pd.to_datetime(df["Commit Timestamp"])
+        df["Target Sync Timestamp"] = pd.to_datetime(df["Target Sync Timestamp"])
+        df["Min Active Read Timestamp"] = pd.to_datetime(
+            df["Min Active Read Timestamp"]
+        )
+        dfRep["Replica Timestamp"] = pd.to_datetime(dfRep["Replica Timestamp"])
+        df["Commit Version"] = df["Commit Version"].astype("int")
+        df["Target Sync Version"] = df["Target Sync Version"].astype("int")
+        df["Min Active Read Version"] = df["Min Active Read Version"].astype("int")
+
+        return df, dfRep
     else:
-        return response.status_code
+        print(f"{sos}\n\n")
+        return df, dfRep
 
 
-def disable_qso(dataset: str, workspace: Optional[str] = None):
+def disable_qso(dataset: str, workspace: Optional[str] = None) -> pd.DataFrame:
     """
     Sets the max read-only replicas to 0, disabling query scale out.
 
@@ -162,15 +159,12 @@ def disable_qso(dataset: str, workspace: Optional[str] = None):
 
     Returns
     -------
+    pandas.DataFrame
+        A pandas dataframe showing the current query scale out settings.
 
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
-
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
     dataset_id = resolve_dataset_id(dataset, workspace)
 
     request_body = {"queryScaleOutSettings": {"maxReadOnlyReplicas": "0"}}
@@ -179,14 +173,15 @@ def disable_qso(dataset: str, workspace: Optional[str] = None):
     response = client.patch(
         f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}", json=request_body
     )
-    if response.status_code == 200:
-        df = list_qso_settings(dataset=dataset, workspace=workspace)
-        print(
-            f"{icons.green_dot} Query scale out has been disabled for the '{dataset}' semantic model within the '{workspace}' workspace."
-        )
-        return df
-    else:
-        raise ValueError(f"{icons.red_dot} {response.status_code}")
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+
+    df = list_qso_settings(dataset=dataset, workspace=workspace)
+    print(
+        f"{icons.green_dot} Query scale out has been disabled for the '{dataset}' semantic model within the '{workspace}' workspace."
+    )
+
+    return df
 
 
 def set_qso(
@@ -194,7 +189,7 @@ def set_qso(
     auto_sync: Optional[bool] = True,
     max_read_only_replicas: Optional[int] = -1,
     workspace: Optional[str] = None,
-):
+) -> pd.DataFrame:
     """
     Sets the query scale out settings for a semantic model.
 
@@ -213,17 +208,14 @@ def set_qso(
 
     Returns
     -------
+    pandas.DataFrame
+        A pandas dataframe showing the current query scale-out settings.
 
     """
 
     # https://learn.microsoft.com/en-us/rest/api/power-bi/datasets/update-dataset-in-group
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
-
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
     dataset_id = resolve_dataset_id(dataset, workspace)
 
     if max_read_only_replicas == 0:
@@ -246,16 +238,19 @@ def set_qso(
             f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}",
             json=request_body,
         )
-        if response.status_code == 200:
-            df = list_qso_settings(dataset=dataset, workspace=workspace)
-            print(
-                f"{icons.green_dot} Query scale out has been set on the '{dataset}' semantic model within the '{workspace}' workspace."
-            )
-            return df
-        else:
-            raise ValueError(f"{icons.red_dot} {response.status_code}")
+        if response.status_code != 200:
+            raise FabricHTTPException(response)
+
+        df = list_qso_settings(dataset=dataset, workspace=workspace)
+        print(
+            f"{icons.green_dot} Query scale out has been set on the '{dataset}' semantic model within the '{workspace}' workspace."
+        )
+        return df
     else:
-        raise ValueError(f"{icons.red_dot} Failed to set the '{dataset}' semantic model within the '{workspace}' workspace to large semantic model storage format. This is a prerequisite for enabling Query Scale Out.\n\"https://learn.microsoft.com/power-bi/enterprise/service-premium-scale-out#prerequisites\"")
+        raise ValueError(
+            f"{icons.red_dot} Failed to set the '{dataset}' semantic model within the '{workspace}' workspace to large semantic model storage format. This is a prerequisite for enabling Query Scale Out.\n\"https://learn.microsoft.com/power-bi/enterprise/service-premium-scale-out#prerequisites\""
+        )
+
 
 def set_semantic_model_storage_format(
     dataset: str, storage_format: str, workspace: Optional[str] = None
@@ -279,12 +274,7 @@ def set_semantic_model_storage_format(
 
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
-
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
     dataset_id = resolve_dataset_id(dataset, workspace)
 
     storage_format = storage_format.capitalize()
@@ -301,21 +291,22 @@ def set_semantic_model_storage_format(
     elif storage_format == "Small":
         request_body = {"targetStorageMode": "Abf"}
     else:
-        raise ValueError(f"{icons.red_dot} Invalid storage format value. Valid options: {storageFormats}.")
+        raise ValueError(
+            f"{icons.red_dot} Invalid storage format value. Valid options: {storageFormats}."
+        )
 
     client = fabric.PowerBIRestClient()
     response = client.patch(
         f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}", json=request_body
     )
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+    print(f"{icons.green_dot} Semantic model storage format set to '{storage_format}'.")
 
-    if response.status_code == 200:
-        return print(
-            f"{icons.green_dot} Semantic model storage format set to '{storage_format}'."
-        )
-    else:
-        raise ValueError(f"{icons.red_dot} {response.status_code}")
 
-def list_qso_settings(dataset: Optional[str] = None, workspace: Optional[str] = None):
+def list_qso_settings(
+    dataset: Optional[str] = None, workspace: Optional[str] = None
+) -> pd.DataFrame:
     """
     Shows the query scale out settings for a semantic model (or all semantic models within a workspace).
 
@@ -334,11 +325,7 @@ def list_qso_settings(dataset: Optional[str] = None, workspace: Optional[str] =
         A pandas dataframe showing the query scale out settings.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
     if dataset is not None:
         dataset_id = resolve_dataset_id(dataset, workspace)
@@ -355,7 +342,8 @@ def list_qso_settings(dataset: Optional[str] = None, workspace: Optional[str] =
     )
     client = fabric.PowerBIRestClient()
     response = client.get(f"/v1.0/myorg/groups/{workspace_id}/datasets")
-    for v in response.json()["value"]:
+
+    for v in response.json().get("value", []):
         tsm = v.get("targetStorageMode")
         if tsm == "Abf":
             sm = "Small"
@@ -365,8 +353,12 @@ def list_qso_settings(dataset: Optional[str] = None, workspace: Optional[str] =
             "Dataset Id": v.get("id"),
             "Dataset Name": v.get("name"),
             "Storage Mode": sm,
-            "QSO Auto Sync Enabled": v.get("queryScaleOutSettings",{}).get("autoSyncReadOnlyReplicas"),
-            "QSO Max Read Only Replicas": v.get("queryScaleOutSettings",{}).get("maxReadOnlyReplicas"),
+            "QSO Auto Sync Enabled": v.get("queryScaleOutSettings", {}).get(
+                "autoSyncReadOnlyReplicas"
+            ),
+            "QSO Max Read Only Replicas": v.get("queryScaleOutSettings", {}).get(
+                "maxReadOnlyReplicas"
+            ),
         }
         df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
@@ -407,23 +399,18 @@ def set_workspace_default_storage_format(
 
     if storage_format not in storageFormats:
         print(
-            f"Invalid storage format. Please choose from these options: {storageFormats}."
+            f"{icons.red_dot} Invalid storage format. Please choose from these options: {storageFormats}."
         )
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
     request_body = {"name": workspace, "defaultDatasetStorageFormat": storage_format}
 
     client = fabric.PowerBIRestClient()
     response = client.patch(f"/v1.0/myorg/groups/{workspace_id}", json=request_body)
 
-    if response.status_code == 200:
-        print(
-            f"{icons.green_dot} The default storage format for the '{workspace}' workspace has been updated to '{storage_format}."
-        )
-    else:
-        raise ValueError(f"{icons.red_dot} {response.status_code}")
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+    print(
+        f"{icons.green_dot} The default storage format for the '{workspace}' workspace has been updated to '{storage_format}."
+    )

sempy_labs/_refresh_semantic_model.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import time
 from sempy_labs._helper_functions import resolve_dataset_id
@@ -6,6 +5,7 @@ from typing import Any, List, Optional, Union
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 from sempy_labs._helper_functions import resolve_workspace_name_and_id
+from sempy.fabric.exceptions import FabricHTTPException
 
 
 @log
@@ -16,6 +16,7 @@ def refresh_semantic_model(
     refresh_type: Optional[str] = None,
     retry_count: Optional[int] = 0,
     apply_refresh_policy: Optional[bool] = True,
+    max_parallelism: Optional[int] = 10,
     workspace: Optional[str] = None,
 ):
     """
@@ -35,6 +36,10 @@ def refresh_semantic_model(
         Number of times the operation retries before failing.
     apply_refresh_policy : bool, default=True
         If an incremental refresh policy is defined, determines whether to apply the policy. Modes are true or false. If the policy isn't applied, the full process leaves partition definitions unchanged, and fully refreshes all partitions in the table. If commitMode is transactional, applyRefreshPolicy can be true or false. If commitMode is partialBatch, applyRefreshPolicy of true isn't supported, and applyRefreshPolicy must be set to false.
+    max_parallelism : int, default=10
+        Determines the maximum number of threads that can run the processing commands in parallel.
+        This value aligns with the MaxParallelism property that can be set in the TMSL Sequence command or by using other methods.
+        Defaults to 10.
     workspace : str, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -79,7 +84,9 @@ def refresh_semantic_model(
     ]
 
     if refresh_type not in refreshTypes:
-        raise ValueError(f"{icons.red_dot} Invalid refresh type. Refresh type must be one of these values: {refreshTypes}.")
+        raise ValueError(
+            f"{icons.red_dot} Invalid refresh type. Refresh type must be one of these values: {refreshTypes}."
+        )
 
     if len(objects) == 0:
         requestID = fabric.refresh_dataset(
@@ -88,6 +95,7 @@ def refresh_semantic_model(
             refresh_type=refresh_type,
             retry_count=retry_count,
             apply_refresh_policy=apply_refresh_policy,
+            max_parallelism=max_parallelism,
         )
     else:
         requestID = fabric.refresh_dataset(
@@ -96,6 +104,7 @@ def refresh_semantic_model(
             refresh_type=refresh_type,
             retry_count=retry_count,
             apply_refresh_policy=apply_refresh_policy,
+            max_parallelism=max_parallelism,
             objects=objects,
         )
     print(
@@ -114,7 +123,9 @@ def refresh_semantic_model(
         if status == "Completed":
             break
         elif status == "Failed":
-            raise ValueError(f"{icons.red_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has failed.")
+            raise ValueError(
+                f"{icons.red_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has failed."
+            )
         elif status == "Cancelled":
             print(
                 f"{icons.yellow_dot} The refresh of the '{dataset}' semantic model within the '{workspace}' workspace has been cancelled."
@@ -155,7 +166,9 @@ def cancel_dataset_refresh(
 
     if request_id is None:
         if len(rr_filt) == 0:
-            raise ValueError(f"{icons.red_dot} There are no active Enhanced API refreshes of the '{dataset}' semantic model within the '{workspace}' workspace.")
+            raise ValueError(
+                f"{icons.red_dot} There are no active Enhanced API refreshes of the '{dataset}' semantic model within the '{workspace}' workspace."
+            )
 
         request_id = rr_filt["Request Id"].iloc[0]
 
@@ -166,9 +179,9 @@ def cancel_dataset_refresh(
     response = client.delete(
         f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}/refreshes/{request_id}"
     )
-    if response.status_code == 200:
-        print(
-            f"{icons.green_dot} The '{request_id}' refresh request for the '{dataset}' semantic model within the '{workspace}' workspace has been cancelled."
-        )
-    else:
-        print(response.status_code)
+
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+    print(
+        f"{icons.green_dot} The '{request_id}' refresh request for the '{dataset}' semantic model within the '{workspace}' workspace has been cancelled."
+    )