semantic-link-labs 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

sempy_labs/lakehouse/_get_lakehouse_tables.py

@@ -2,7 +2,7 @@ import os
 import pandas as pd
 import pyarrow.parquet as pq
 from datetime import datetime
-from sempy_labs._helper_functions import (
+from .._helper_functions import (
     _get_column_aggregate,
     resolve_workspace_name_and_id,
     resolve_lakehouse_name_and_id,
@@ -15,11 +15,11 @@ from sempy_labs._helper_functions import (
     create_abfss_path,
     _pure_python_notebook,
 )
-from sempy_labs.directlake._guardrails import (
+from ..directlake._guardrails import (
     get_sku_size,
     get_directlake_guardrails_for_sku,
 )
-from sempy_labs.lakehouse._lakehouse import lakehouse_attached
+from ._lakehouse import lakehouse_attached
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy._utils._log import log
@@ -97,7 +97,7 @@ def get_lakehouse_tables(
     except Exception as e:
         API_called = False
 
-    dfs = []
+    rows = []
     local_path = None
     if API_called:
         if not responses[0].get("data"):
@@ -105,16 +105,17 @@ def get_lakehouse_tables(
 
         for r in responses:
             for i in r.get("data", []):
-                new_data = {
-                    "Workspace Name": workspace_name,
-                    "Lakehouse Name": lakehouse_name,
-                    "Schema Name": "",
-                    "Table Name": i.get("name"),
-                    "Format": i.get("format"),
-                    "Type": i.get("type"),
-                    "Location": i.get("location"),
-                }
-                dfs.append(pd.DataFrame(new_data, index=[0]))
+                rows.append(
+                    {
+                        "Workspace Name": workspace_name,
+                        "Lakehouse Name": lakehouse_name,
+                        "Schema Name": "",
+                        "Table Name": i.get("name"),
+                        "Format": i.get("format"),
+                        "Type": i.get("type"),
+                        "Location": i.get("location"),
+                    }
+                )
     else:
         local_path = _mount(lakehouse=lakehouse_id, workspace=workspace_id)
         tables_path = os.path.join(local_path, "Tables")
@@ -127,19 +128,20 @@ def get_lakehouse_tables(
                 location_path = create_abfss_path(
                     lakehouse_id, workspace_id, table_name, schema_name
                 )
-                new_data = {
-                    "Workspace Name": workspace_name,
-                    "Lakehouse Name": lakehouse_name,
-                    "Schema Name": schema_name,
-                    "Table Name": table_name,
-                    "Format": "delta",
-                    "Type": "Managed",
-                    "Location": location_path,
-                }
-                dfs.append(pd.DataFrame(new_data, index=[0]))
-
-    if dfs:
-        df = pd.concat(dfs, ignore_index=True)
+                rows.append(
+                    {
+                        "Workspace Name": workspace_name,
+                        "Lakehouse Name": lakehouse_name,
+                        "Schema Name": schema_name,
+                        "Table Name": table_name,
+                        "Format": "delta",
+                        "Type": "Managed",
+                        "Location": location_path,
+                    }
+                )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
 
     if extended:
         sku_value = get_sku_size(workspace_id)

sempy_labs/lakehouse/_helper.py

@@ -11,6 +11,7 @@ from sempy_labs._helper_functions import (
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 import os
+import json
 
 
 @log
@@ -51,7 +52,43 @@ def is_v_ordered(
     )
     ds_schema = ds.dataset(table_path).schema.metadata
 
-    return any(b"vorder" in key for key in ds_schema.keys())
+    if ds_schema:
+        return any(b"vorder" in key for key in ds_schema.keys())
+
+    delta_log_path = os.path.join(table_path, "_delta_log")
+
+    def read_vorder_tag(delta_log_path):
+        json_files = sorted(
+            [f for f in os.listdir(delta_log_path) if f.endswith(".json")], reverse=True
+        )
+
+        if not json_files:
+            return False
+
+        latest_file = os.path.join(delta_log_path, json_files[0])
+
+        with open(latest_file, "r") as f:
+            all_data = [
+                json.loads(line) for line in f if line.strip()
+            ]  # one dict per line
+            for data in all_data:
+                if "metaData" in data:
+                    return (
+                        data.get("metaData", {})
+                        .get("configuration", {})
+                        .get("delta.parquet.vorder.enabled", "false")
+                        == "true"
+                    )
+
+            # If no metaData, fall back to commitInfo
+            for data in all_data:
+                if "commitInfo" in data:
+                    tags = data["commitInfo"].get("tags", {})
+                    return tags.get("VORDER", "false").lower() == "true"
+
+        return False  # Default if not found
+
+    return read_vorder_tag(delta_log_path)
 
 
 @log

sempy_labs/lakehouse/_lakehouse.py

@@ -100,11 +100,15 @@ def optimize_lakehouse_tables(
         tables = [tables]
 
     df_tables = df_delta[df_delta["Table Name"].isin(tables)] if tables else df_delta
+    df_tables.reset_index(drop=True, inplace=True)
 
-    for _, r in (bar := tqdm(df_tables.iterrows())):
+    total = len(df_tables)
+    for idx, r in (bar := tqdm(df_tables.iterrows(), total=total, bar_format="{desc}")):
         table_name = r["Table Name"]
         path = r["Location"]
-        bar.set_description(f"Optimizing the '{table_name}' table...")
+        bar.set_description(
+            f"Optimizing the '{table_name}' table ({idx + 1}/{total})..."
+        )
         _optimize_table(path=path)
 
 
@@ -145,11 +149,13 @@ def vacuum_lakehouse_tables(
         tables = [tables]
 
     df_tables = df_delta[df_delta["Table Name"].isin(tables)] if tables else df_delta
+    df_tables.reset_index(drop=True, inplace=True)
 
-    for _, r in (bar := tqdm(df_tables.iterrows())):
+    total = len(df_tables)
+    for idx, r in (bar := tqdm(df_tables.iterrows(), total=total, bar_format="{desc}")):
         table_name = r["Table Name"]
         path = r["Location"]
-        bar.set_description(f"Vacuuming the '{table_name}' table...")
+        bar.set_description(f"Vacuuming the '{table_name}' table ({idx}/{total})...")
         _vacuum_table(path=path, retain_n_hours=retain_n_hours)
 
 
@@ -231,7 +237,7 @@ def run_table_maintenance(
     if optimize:
         payload["executionData"]["optimizeSettings"] = {}
     if v_order:
-        payload["executionData"]["optimizeSettings"] = {"vorder": True}
+        payload["executionData"]["optimizeSettings"] = {"vOrder": True}
     if vacuum:
         payload["executionData"]["vacuumSettings"] = {}
     if vacuum and retention_period is not None:
@@ -242,16 +248,19 @@ def run_table_maintenance(
         method="post",
         payload=payload,
         status_codes=202,
+        client="fabric_sp",
     )
 
-    f"{icons.in_progress} The table maintenance job for the '{table_name}' table in the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has been initiated."
+    print(
+        f"{icons.in_progress} The table maintenance job for the '{table_name}' table in the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has been initiated."
+    )
 
     status_url = response.headers.get("Location").split("fabric.microsoft.com")[1]
     status = None
     while status not in ["Completed", "Failed"]:
         response = _base_api(request=status_url)
         status = response.json().get("status")
-        time.sleep(10)
+        time.sleep(3)
 
     df = _get_item_job_instance(url=status_url)
 

sempy_labs/lakehouse/_livy_sessions.py

@@ -1,4 +1,4 @@
-from sempy_labs._helper_functions import (
+from .._helper_functions import (
     resolve_workspace_id,
     resolve_lakehouse_id,
     _base_api,
@@ -86,53 +86,58 @@ def list_livy_sessions(
         client="fabric_sp",
     )
 
-    dfs = []
+    rows = []
     for r in responses:
         for v in r.get("value", []):
             queued_duration = v.get("queuedDuration", {})
             running_duration = v.get("runningDuration", {})
             total_duration = v.get("totalDuration", {})
-            new_data = {
-                "Spark Application Id": v.get("sparkApplicationId"),
-                "State:": v.get("state"),
-                "Livy Id": v.get("livyId"),
-                "Origin": v.get("origin"),
-                "Attempt Number": v.get("attemptNumber"),
-                "Max Number Of Attempts": v.get("maxNumberOfAttempts"),
-                "Livy Name": v.get("livyName"),
-                "Submitter Id": v["submitter"].get("id"),
-                "Submitter Type": v["submitter"].get("type"),
-                "Item Workspace Id": v["item"].get("workspaceId"),
-                "Item Id": v["item"].get("itemId"),
-                "Item Reference Type": v["item"].get("referenceType"),
-                "Item Name": v.get("itemName"),
-                "Item Type": v.get("itemType"),
-                "Job Type": v.get("jobType"),
-                "Submitted Date Time": v.get("submittedDateTime"),
-                "Start Date Time": v.get("startDateTime"),
-                "End Date Time": v.get("endDateTime"),
-                "Queued Duration Value": queued_duration.get("value"),
-                "Queued Duration Time Unit": queued_duration.get("timeUnit"),
-                "Running Duration Value": running_duration.get("value"),
-                "Running Duration Time Unit": running_duration.get("timeUnit"),
-                "Total Duration Value": total_duration.get("value"),
-                "Total Duration Time Unit": total_duration.get("timeUnit"),
-                "Job Instance Id": v.get("jobInstanceId"),
-                "Creator Item Workspace Id": v["creatorItem"].get("workspaceId"),
-                "Creator Item Id": v["creatorItem"].get("itemId"),
-                "Creator Item Reference Type": v["creatorItem"].get("referenceType"),
-                "Creator Item Name": v.get("creatorItemName"),
-                "Creator Item Type": v.get("creatorItemType"),
-                "Cancellation Reason": v.get("cancellationReason"),
-                "Capacity Id": v.get("capacityId"),
-                "Operation Name": v.get("operationName"),
-                "Runtime Version": v.get("runtimeVersion"),
-                "Livy Session Item Resource Uri": v.get("livySessionItemResourceUri"),
-            }
-            dfs.append(pd.DataFrame(new_data, index=[0]))
+            rows.append(
+                {
+                    "Spark Application Id": v.get("sparkApplicationId"),
+                    "State:": v.get("state"),
+                    "Livy Id": v.get("livyId"),
+                    "Origin": v.get("origin"),
+                    "Attempt Number": v.get("attemptNumber"),
+                    "Max Number Of Attempts": v.get("maxNumberOfAttempts"),
+                    "Livy Name": v.get("livyName"),
+                    "Submitter Id": v["submitter"].get("id"),
+                    "Submitter Type": v["submitter"].get("type"),
+                    "Item Workspace Id": v["item"].get("workspaceId"),
+                    "Item Id": v["item"].get("itemId"),
+                    "Item Reference Type": v["item"].get("referenceType"),
+                    "Item Name": v.get("itemName"),
+                    "Item Type": v.get("itemType"),
+                    "Job Type": v.get("jobType"),
+                    "Submitted Date Time": v.get("submittedDateTime"),
+                    "Start Date Time": v.get("startDateTime"),
+                    "End Date Time": v.get("endDateTime"),
+                    "Queued Duration Value": queued_duration.get("value"),
+                    "Queued Duration Time Unit": queued_duration.get("timeUnit"),
+                    "Running Duration Value": running_duration.get("value"),
+                    "Running Duration Time Unit": running_duration.get("timeUnit"),
+                    "Total Duration Value": total_duration.get("value"),
+                    "Total Duration Time Unit": total_duration.get("timeUnit"),
+                    "Job Instance Id": v.get("jobInstanceId"),
+                    "Creator Item Workspace Id": v["creatorItem"].get("workspaceId"),
+                    "Creator Item Id": v["creatorItem"].get("itemId"),
+                    "Creator Item Reference Type": v["creatorItem"].get(
+                        "referenceType"
+                    ),
+                    "Creator Item Name": v.get("creatorItemName"),
+                    "Creator Item Type": v.get("creatorItemType"),
+                    "Cancellation Reason": v.get("cancellationReason"),
+                    "Capacity Id": v.get("capacityId"),
+                    "Operation Name": v.get("operationName"),
+                    "Runtime Version": v.get("runtimeVersion"),
+                    "Livy Session Item Resource Uri": v.get(
+                        "livySessionItemResourceUri"
+                    ),
+                }
+            )
 
-    if dfs:
-        df = pd.concat(dfs, ignore_index=True)
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
         _update_dataframe_datatypes(dataframe=df, column_map=columns)
 
     return df

sempy_labs/lakehouse/_shortcuts.py

@@ -1,6 +1,6 @@
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs._helper_functions import (
+from .._helper_functions import (
     resolve_lakehouse_name_and_id,
     resolve_workspace_name_and_id,
     _base_api,
@@ -371,7 +371,7 @@ def list_shortcuts(
         "S3Compatible": "s3Compatible",
     }
 
-    dfs = []
+    rows = []
     for r in responses:
         for i in r.get("value", []):
             tgt = i.get("target", {})
@@ -402,25 +402,26 @@ def list_shortcuts(
                 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),
-            }
-            dfs.append(pd.DataFrame(new_data, index=[0]))
+            rows.append(
+                {
+                    "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),
+                }
+            )
 
-    if dfs:
-        df = pd.concat(dfs, ignore_index=True)
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
 
     return df

sempy_labs/migration/__init__.py

@@ -1,24 +1,24 @@
-from sempy_labs.migration._create_pqt_file import create_pqt_file
-from sempy_labs.migration._migrate_calctables_to_lakehouse import (
+from ._create_pqt_file import create_pqt_file
+from ._migrate_calctables_to_lakehouse import (
     migrate_calc_tables_to_lakehouse,
     migrate_field_parameters,
 )
-from sempy_labs.migration._migrate_calctables_to_semantic_model import (
+from ._migrate_calctables_to_semantic_model import (
     migrate_calc_tables_to_semantic_model,
 )
-from sempy_labs.migration._migrate_model_objects_to_semantic_model import (
+from ._migrate_model_objects_to_semantic_model import (
     migrate_model_objects_to_semantic_model,
 )
-from sempy_labs.migration._migrate_tables_columns_to_semantic_model import (
+from ._migrate_tables_columns_to_semantic_model import (
     migrate_tables_columns_to_semantic_model,
 )
-from sempy_labs.migration._migration_validation import (
+from ._migration_validation import (
     migration_validation,
 )
-from sempy_labs.migration._refresh_calc_tables import (
+from ._refresh_calc_tables import (
     refresh_calc_tables,
 )
-from sempy_labs.migration._direct_lake_to_import import (
+from ._direct_lake_to_import import (
     migrate_direct_lake_to_import,
 )
 

sempy_labs/migration/_create_pqt_file.py

@@ -2,12 +2,12 @@ import sempy
 import json
 import os
 import shutil
-from sempy_labs.lakehouse._lakehouse import lakehouse_attached
+from ..lakehouse._lakehouse import lakehouse_attached
 from sempy._utils._log import log
 from typing import Optional
 import sempy_labs._icons as icons
 from uuid import UUID
-from sempy_labs._helper_functions import (
+from .._helper_functions import (
     resolve_dataset_name_and_id,
     resolve_workspace_name_and_id,
 )

sempy_labs/migration/_migrate_calctables_to_lakehouse.py

@@ -4,26 +4,27 @@ import pandas as pd
 import re
 from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
 from sempy_labs._helper_functions import (
-    resolve_lakehouse_name,
-    resolve_lakehouse_id,
     retry,
     generate_guid,
     save_as_delta_table,
+    resolve_lakehouse_name_and_id,
+    resolve_workspace_name_and_id,
 )
 from sempy_labs.tom import connect_semantic_model
 from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 @log
 def migrate_calc_tables_to_lakehouse(
     dataset: str,
     new_dataset: str,
-    workspace: Optional[str] = None,
-    new_dataset_workspace: Optional[str] = None,
-    lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
+    new_dataset_workspace: Optional[str | UUID] = None,
+    lakehouse: Optional[str | UUID] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
 ):
     """
     Creates delta tables in your lakehouse based on the DAX expression of a calculated table in an import/DirectQuery semantic model.
@@ -35,18 +36,18 @@ def migrate_calc_tables_to_lakehouse(
         Name of the import/DirectQuery semantic model.
     new_dataset : str
         Name of the Direct Lake semantic model.
-    workspace : str, default=None
+    workspace : str | uuid.UUID, default=None
         The Fabric workspace name in which the import/DirectQuery semantic model exists.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
-    new_dataset_workspace : str
+    new_dataset_workspace : str | uuid.UUID
         The Fabric workspace name in which the Direct Lake semantic model will be created.
         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
+    lakehouse : str | uuid.UUID, 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
+    lakehouse_workspace : str | uuid.UUID, 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.
@@ -57,22 +58,16 @@ def migrate_calc_tables_to_lakehouse(
             f"{icons.red_dot} The 'dataset' and 'new_dataset' parameters are both set to '{dataset}'. These parameters must be set to different values."
         )
 
-    workspace = fabric.resolve_workspace_name(workspace)
-
-    if new_dataset_workspace is None:
-        new_dataset_workspace = workspace
-
-    if lakehouse_workspace is None:
-        lakehouse_workspace = new_dataset_workspace
-        lakehouse_workspace_id = fabric.resolve_workspace_id(lakehouse_workspace)
-    else:
-        lakehouse_workspace_id = fabric.resolve_workspace_id(lakehouse_workspace)
-
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
-    else:
-        lakehouse_id = resolve_lakehouse_id(lakehouse, lakehouse_workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (new_dataset_workspace_name, new_dataset_workspace_id) = (
+        resolve_workspace_name_and_id(new_dataset_workspace)
+    )
+    (lakehouse_workspace_id, lakehouse_workspace_name) = resolve_workspace_name_and_id(
+        lakehouse_workspace
+    )
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse, lakehouse_workspace
+    )
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     dfP_filt = dfP[(dfP["Source Type"] == "Calculated")]
@@ -90,7 +85,7 @@ def migrate_calc_tables_to_lakehouse(
 
         if dtName in lakeTables["Table Name"].values:
             print(
-                f"{icons.red_dot} The '{tName}' table already exists as '{dtName}' in the '{lakehouse}' lakehouse in the '{workspace}' workspace."
+                f"{icons.red_dot} The '{tName}' table already exists as '{dtName}' in the '{lakehouse_name}' lakehouse in the '{lakehouse_workspace_name}' workspace."
             )
             killFunction = True
 
@@ -99,7 +94,7 @@ def migrate_calc_tables_to_lakehouse(
 
     if len(dfP_filt) == 0:
         print(
-            f"{icons.yellow_dot} The '{dataset}' semantic model in the '{workspace}' workspace has no calculated tables."
+            f"{icons.yellow_dot} The '{dataset}' semantic model in the '{workspace_name}' workspace has no calculated tables."
         )
         return
 
@@ -175,7 +170,6 @@ def migrate_calc_tables_to_lakehouse(
                                             if str(c.Type) == "Calculated"
                                             and c.Name == new_column_name
                                         )
-
                                     if dataType == "Int64":
                                         df[new_column_name] = df[
                                             new_column_name
@@ -197,7 +191,7 @@ def migrate_calc_tables_to_lakehouse(
 
                                 save_as_delta_table(
                                     dataframe=df,
-                                    table_name=delta_table_name,
+                                    delta_table_name=delta_table_name,
                                     lakehouse=lakehouse,
                                     workspace=lakehouse_workspace,
                                     write_mode="overwrite",
@@ -231,20 +225,21 @@ def migrate_calc_tables_to_lakehouse(
 
                                 print(
                                     f"{icons.green_dot} Calculated table '{t.Name}' has been created as delta table '{delta_table_name.lower()}' "
-                                    f"in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
+                                    f"in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace_name}' workspace."
                                 )
-                            except Exception:
+                            except Exception as e:
                                 print(
                                     f"{icons.red_dot} Failed to create calculated table '{t.Name}' as a delta table in the lakehouse."
                                 )
+                                print(e)
 
 
 @log
 def migrate_field_parameters(
     dataset: str,
     new_dataset: str,
-    workspace: Optional[str] = None,
-    new_dataset_workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
+    new_dataset_workspace: Optional[str | UUID] = None,
 ):
     """
     Migrates field parameters from one semantic model to another.
@@ -255,11 +250,11 @@ def migrate_field_parameters(
         Name of the import/DirectQuery semantic model.
     new_dataset : str
         Name of the Direct Lake semantic model.
-    workspace : str, default=None
+    workspace : str | uuid.UUID, default=None
         The Fabric workspace name in which the import/DirectQuery semantic model exists.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
-    new_dataset_workspace : str
+    new_dataset_workspace : str | uuid.UUID, default=None
         The Fabric workspace name in which the Direct Lake semantic model will be created.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
@@ -270,15 +265,11 @@ def migrate_field_parameters(
     sempy.fabric._client._utils._init_analysis_services()
     import Microsoft.AnalysisServices.Tabular as TOM
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
-    if new_dataset_workspace is None:
-        new_dataset_workspace = workspace
-
     icons.sll_tags.append("DirectLakeMigration")
     fabric.refresh_tom_cache(workspace=workspace)
+    (new_dataset_workspace_name, new_dataset_workspace_id) = (
+        resolve_workspace_name_and_id(new_dataset_workspace)
+    )
 
     dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
     dfC["Column Object"] = format_dax_object_name(dfC["Table Name"], dfC["Column Name"])
@@ -399,7 +390,7 @@ def migrate_field_parameters(
                 tom.model.Tables[tName].Columns["Value3"].Name = col3
 
                 print(
-                    f"{icons.green_dot} The '{tName}' table has been added as a field parameter to the '{new_dataset}' semantic model in the '{new_dataset_workspace}' workspace."
+                    f"{icons.green_dot} The '{tName}' table has been added as a field parameter to the '{new_dataset}' semantic model in the '{new_dataset_workspace_name}' workspace."
                 )
             except Exception:
                 print(