semantic-link-labs 0.4.1__py3-none-any.whl

sempy_labs/migration/_create_pqt_file.py

@@ -0,0 +1,239 @@
+import sempy
+import sempy.fabric as fabric
+import json, os, shutil
+import xml.etree.ElementTree as ET
+from sempy_labs._list_functions import list_tables
+from sempy_labs.lakehouse._lakehouse import lakehouse_attached
+from sempy._utils._log import log
+from typing import Optional
+import sempy_labs._icons as icons
+
+
+@log
+def create_pqt_file(
+    dataset: str, workspace: Optional[str] = None, file_name: Optional[str] = None
+):
+    """
+    Dynamically generates a `Power Query Template <https://learn.microsoft.com/power-query/power-query-template>`_ file based on the semantic model. The .pqt file is saved within the Files section of your lakehouse.
+
+    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.
+    file_name : str, default=None
+        The name of the Power Query Template file to be generated.
+        Defaults to None which resolves to 'PowerQueryTemplate'.
+    """
+
+    if file_name is None:
+        file_name = "PowerQueryTemplate"
+
+    lakeAttach = lakehouse_attached()
+
+    if lakeAttach == False:
+        print(
+            f"{icons.red_dot} In order to run the 'create_pqt_file' function, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
+        )
+        return
+
+    if workspace == None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+
+    folderPath = "/lakehouse/default/Files"
+    subFolderPath = os.path.join(folderPath, "pqtnewfolder")
+    os.makedirs(subFolderPath, exist_ok=True)
+
+    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+    dfT = list_tables(dataset, workspace)
+    dfE = fabric.list_expressions(dataset=dataset, workspace=workspace)
+
+    # Check if M-partitions are used
+    if any(dfP["Source Type"] == "M"):
+
+        class QueryMetadata:
+            def __init__(
+                self,
+                QueryName,
+                QueryGroupId=None,
+                LastKnownIsParameter=None,
+                LastKnownResultTypeName=None,
+                LoadEnabled=True,
+                IsHidden=False,
+            ):
+                self.QueryName = QueryName
+                self.QueryGroupId = QueryGroupId
+                self.LastKnownIsParameter = LastKnownIsParameter
+                self.LastKnownResultTypeName = LastKnownResultTypeName
+                self.LoadEnabled = LoadEnabled
+                self.IsHidden = IsHidden
+
+        class RootObject:
+            def __init__(
+                self, DocumentLocale, EngineVersion, QueriesMetadata, QueryGroups=None
+            ):
+                if QueryGroups is None:
+                    QueryGroups = []
+                self.DocumentLocale = DocumentLocale
+                self.EngineVersion = EngineVersion
+                self.QueriesMetadata = QueriesMetadata
+                self.QueryGroups = QueryGroups
+
+        # STEP 1: Create MashupDocument.pq
+        mdfileName = "MashupDocument.pq"
+        mdFilePath = os.path.join(subFolderPath, mdfileName)
+        sb = "section Section1;"
+        for table_name in dfP["Table Name"].unique():
+            tName = '#"' + table_name + '"'
+            sourceExpression = dfT.loc[
+                (dfT["Name"] == table_name), "Source Expression"
+            ].iloc[0]
+            refreshPolicy = dfT.loc[(dfT["Name"] == table_name), "Refresh Policy"].iloc[
+                0
+            ]
+            sourceType = dfP.loc[(dfP["Table Name"] == table_name), "Source Type"].iloc[
+                0
+            ]
+
+            if sourceType == "M" or refreshPolicy:
+                sb = sb + "\n" + "shared " + tName + " = "
+
+            partitions_in_table = dfP.loc[
+                dfP["Table Name"] == table_name, "Partition Name"
+            ].unique()
+
+            i = 1
+            for partition_name in partitions_in_table:
+                pSourceType = dfP.loc[
+                    (dfP["Table Name"] == table_name)
+                    & (dfP["Partition Name"] == partition_name),
+                    "Source Type",
+                ].iloc[0]
+                pQuery = dfP.loc[
+                    (dfP["Table Name"] == table_name)
+                    & (dfP["Partition Name"] == partition_name),
+                    "Query",
+                ].iloc[0]
+
+                if pQuery is not None:
+                    pQueryNoSpaces = (
+                        pQuery.replace(" ", "")
+                        .replace("\n", "")
+                        .replace("\t", "")
+                        .replace("\r", "")
+                    )
+                    if pQueryNoSpaces.startswith('letSource=""'):
+                        pQuery = 'let\n\tSource = ""\nin\n\tSource'
+
+                if pSourceType == "M" and i == 1:
+                    sb = sb + pQuery + ";"
+                elif refreshPolicy and i == 1:
+                    sb = sb + sourceExpression + ";"
+                i += 1
+
+        for index, row in dfE.iterrows():
+            expr = row["Expression"]
+            eName = row["Name"]
+            eName = '#"' + eName + '"'
+            sb = sb + "\n" + "shared " + eName + " = " + expr + ";"
+
+        with open(mdFilePath, "w") as file:
+            file.write(sb)
+
+        # STEP 2: Create the MashupMetadata.json file
+        mmfileName = "MashupMetadata.json"
+        mmFilePath = os.path.join(subFolderPath, mmfileName)
+        queryMetadata = []
+
+        for tName in dfP["Table Name"].unique():
+            sourceType = dfP.loc[(dfP["Table Name"] == tName), "Source Type"].iloc[0]
+            refreshPolicy = dfT.loc[(dfT["Name"] == tName), "Refresh Policy"].iloc[0]
+            if sourceType == "M" or refreshPolicy:
+                queryMetadata.append(
+                    QueryMetadata(tName, None, None, None, True, False)
+                )
+
+        for i, r in dfE.iterrows():
+            eName = r["Name"]
+            eKind = r["Kind"]
+            if eKind == "M":
+                queryMetadata.append(
+                    QueryMetadata(eName, None, None, None, True, False)
+                )
+            else:
+                queryMetadata.append(
+                    QueryMetadata(eName, None, None, None, False, False)
+                )
+
+        rootObject = RootObject("en-US", "2.126.453.0", queryMetadata)
+
+        def obj_to_dict(obj):
+            if isinstance(obj, list):
+                return [obj_to_dict(e) for e in obj]
+            elif hasattr(obj, "__dict__"):
+                return {k: obj_to_dict(v) for k, v in obj.__dict__.items()}
+            else:
+                return obj
+
+        jsonContent = json.dumps(obj_to_dict(rootObject), indent=4)
+
+        with open(mmFilePath, "w") as json_file:
+            json_file.write(jsonContent)
+
+        # STEP 3: Create Metadata.json file
+        mFileName = "Metadata.json"
+        mFilePath = os.path.join(subFolderPath, mFileName)
+        metaData = {"Name": "fileName", "Description": "", "Version": "1.0.0.0"}
+        jsonContent = json.dumps(metaData, indent=4)
+
+        with open(mFilePath, "w") as json_file:
+            json_file.write(jsonContent)
+
+        # STEP 4: Create [Content_Types].xml file:
+        ns = "http://schemas.openxmlformats.org/package/2006/content-types"
+        ET.register_namespace("", ns)
+        types = ET.Element("{%s}Types" % ns)
+        default1 = ET.SubElement(
+            types,
+            "{%s}Default" % ns,
+            {"Extension": "json", "ContentType": "application/json"},
+        )
+        default2 = ET.SubElement(
+            types,
+            "{%s}Default" % ns,
+            {"Extension": "pq", "ContentType": "application/x-ms-m"},
+        )
+        xmlDocument = ET.ElementTree(types)
+        xmlFileName = "[Content_Types].xml"
+        xmlFilePath = os.path.join(subFolderPath, xmlFileName)
+        xmlDocument.write(
+            xmlFilePath, xml_declaration=True, encoding="utf-8", method="xml"
+        )
+
+        # STEP 5: Zip up the 4 files
+        zipFileName = file_name + ".zip"
+        zipFilePath = os.path.join(folderPath, zipFileName)
+        shutil.make_archive(zipFilePath[:-4], "zip", subFolderPath)
+
+        # STEP 6: Convert the zip file back into a .pqt file
+        newExt = ".pqt"
+        directory = os.path.dirname(zipFilePath)
+        fileNameWithoutExtension = os.path.splitext(os.path.basename(zipFilePath))[0]
+        newFilePath = os.path.join(directory, fileNameWithoutExtension + newExt)
+        shutil.move(zipFilePath, newFilePath)
+
+        # STEP 7: Delete subFolder directory which is no longer needed
+        shutil.rmtree(subFolderPath, ignore_errors=True)
+
+        print(
+            f"{icons.green_dot} '{file_name}.pqt' has been created based on the '{dataset}' semantic model in the '{workspace}' workspace within the Files section of your lakehouse."
+        )
+
+    else:
+        print(
+            f"{icons.yellow_dot} The '{dataset}' semantic model in the '{workspace}' workspace does not use Power Query so a Power Query Template file cannot be generated."
+        )

sempy_labs/migration/_migrate_calctables_to_lakehouse.py

@@ -0,0 +1,429 @@
+import sempy
+import sempy.fabric as fabric
+import pandas as pd
+import re, datetime, time
+from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
+from sempy_labs._helper_functions import (
+    resolve_lakehouse_name,
+    resolve_lakehouse_id,
+    create_abfss_path,
+)
+from sempy_labs._tom import connect_semantic_model
+from pyspark.sql import SparkSession
+from typing import List, Optional, Union
+from sempy._utils._log import log
+import sempy_labs._icons as icons
+
+
+@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,
+):
+    """
+    Creates delta tables in your lakehouse based on the DAX expression of a calculated table in an import/DirectQuery semantic model. The DAX expression encapsulating the calculated table logic is stored in the new Direct Lake semantic model as model annotations.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the import/DirectQuery semantic model.
+    new_dataset : str
+        Name of the Direct Lake semantic model.
+    workspace : str, 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
+        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
+        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.
+    """
+
+    workspace = fabric.resolve_workspace_name(workspace)
+
+    if new_dataset_workspace == None:
+        new_dataset_workspace = workspace
+
+    if lakehouse_workspace == 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 == None:
+        lakehouse_id = fabric.get_lakehouse_id()
+        lakehouse = resolve_lakehouse_name(lakehouse_id, lakehouse_workspace)
+    else:
+        lakehouse_id = resolve_lakehouse_id(lakehouse, lakehouse_workspace)
+
+    dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
+    # dfC['Column Object'] = "'" + dfC['Table Name'] + "'[" + dfC['Column Name'] + "]"
+    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+    dfP_filt = dfP[(dfP["Source Type"] == "Calculated")]
+    dfP_filt = dfP_filt[
+        ~dfP_filt["Query"].str.contains("NAMEOF")
+    ]  # Remove field parameters
+    # dfC_CalcColumn = dfC[dfC['Type'] == 'Calculated']
+    lakeTables = get_lakehouse_tables(lakehouse, lakehouse_workspace)
+
+    # Do not execute the function if lakehouse tables already exist with the same name
+    killFunction = False
+    for i, r in dfP_filt.iterrows():
+        tName = r["Table Name"]
+        dtName = tName.replace(" ", "_")
+
+        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."
+            )
+            killFunction = True
+
+    if killFunction:
+        return
+
+    spark = SparkSession.builder.getOrCreate()
+
+    if len(dfP_filt) == 0:
+        print(
+            f"{icons.yellow_dot} The '{dataset}' semantic model in the '{workspace}' workspace has no calculated tables."
+        )
+        return
+
+    start_time = datetime.datetime.now()
+    timeout = datetime.timedelta(minutes=1)
+    success = False
+
+    while not success:
+        try:
+            with connect_semantic_model(
+                dataset=dataset, workspace=workspace, readonly=True
+            ) as tom:
+                success = True
+                for t in tom.model.Tables:
+                    if tom.is_auto_date_table(table_name=t.Name):
+                        print(
+                            f"{icons.yellow_dot} The '{t.Name}' table is an auto-datetime table and is not supported in the Direct Lake migration process. Please create a proper Date/Calendar table in your lakehoues and use it in your Direct Lake model."
+                        )
+                    else:
+                        for p in t.Partitions:
+                            if str(p.SourceType) == "Calculated":
+                                query = p.Source.Expression
+                                if "NAMEOF" not in query:  # exclude field parameters
+                                    daxQuery = ""
+                                    if query.lower().startswith("calendar") and any(
+                                        str(c.Type) == "Calculated" for c in t.Columns
+                                    ):
+                                        daxQuery = f"ADDCOLUMNS(\n{query},"
+                                        for c in t.Columns:
+                                            if str(c.Type) == "Calculated":
+                                                expr = c.Expression
+                                                expr = expr.replace(
+                                                    f"'{t.Name}'", ""
+                                                ).replace(f"{t.Name}[Date]", "[Date]")
+                                                expr = expr.replace(
+                                                    "[MonthNo]", "MONTH([Date])"
+                                                ).replace(
+                                                    "[QuarterNo]",
+                                                    "INT((MONTH([Date]) + 2) / 3)",
+                                                )
+                                                daxQuery = (
+                                                    f'{daxQuery}\n"{c.Name}",{expr},'
+                                                )
+                                        daxQuery = (
+                                            "EVALUATE\n" + daxQuery.rstrip(",") + "\n)"
+                                        )
+                                    else:
+                                        daxQuery = f"EVALUATE\n{query}"
+                                    daxQueryTopN = (
+                                        daxQuery.replace(
+                                            "EVALUATE\n", "EVALUATE\nTOPN(1,"
+                                        )
+                                        + ")"
+                                    )
+
+                                    try:
+                                        df = fabric.evaluate_dax(
+                                            dataset=dataset,
+                                            dax_string=daxQueryTopN,
+                                            workspace=workspace,
+                                        )
+
+                                        for col in df.columns:
+                                            pattern = r"\[([^\]]+)\]"
+
+                                            matches = re.findall(pattern, col)
+                                            new_column_name = matches[0].replace(
+                                                " ", ""
+                                            )
+
+                                            df.rename(
+                                                columns={col: new_column_name},
+                                                inplace=True,
+                                            )
+
+                                            try:
+                                                dataType = next(
+                                                    str(c.DataType)
+                                                    for c in tom.model.Tables[
+                                                        t.Name
+                                                    ].Columns
+                                                    if str(c.Type)
+                                                    == "CalculatedTableColumn"
+                                                    and c.SourceColumn == col
+                                                )
+                                            except:
+                                                dataType = next(
+                                                    str(c.DataType)
+                                                    for c in tom.model.Tables[
+                                                        t.Name
+                                                    ].Columns
+                                                    if str(c.Type) == "Calculated"
+                                                    and c.Name == new_column_name
+                                                )
+
+                                            if dataType == "Int64":
+                                                df[new_column_name] = df[
+                                                    new_column_name
+                                                ].astype(int)
+                                            elif dataType in ["Decimal", "Double"]:
+                                                df[new_column_name] = df[
+                                                    new_column_name
+                                                ].astype(float)
+                                            elif dataType == "Boolean":
+                                                df[new_column_name] = df[
+                                                    new_column_name
+                                                ].astype(bool)
+                                            elif dataType == "DateTime":
+                                                df[new_column_name] = pd.to_datetime(
+                                                    df[new_column_name]
+                                                )
+
+                                        delta_table_name = t.Name.replace(
+                                            " ", "_"
+                                        ).lower()
+
+                                        spark_df = spark.createDataFrame(df)
+                                        filePath = create_abfss_path(
+                                            lakehouse_id=lakehouse_id,
+                                            lakehouse_workspace_id=lakehouse_workspace_id,
+                                            delta_table_name=delta_table_name,
+                                        )
+                                        spark_df.write.mode("overwrite").format(
+                                            "delta"
+                                        ).save(filePath)
+
+                                        start_time2 = datetime.datetime.now()
+                                        timeout2 = datetime.timedelta(minutes=1)
+                                        success2 = False
+
+                                        while not success2:
+                                            try:
+                                                with connect_semantic_model(
+                                                    dataset=new_dataset,
+                                                    readonly=False,
+                                                    workspace=new_dataset_workspace,
+                                                ) as tom2:
+                                                    success2 = True
+                                                    tom2.set_annotation(
+                                                        object=tom2.model,
+                                                        name=t.Name,
+                                                        value=daxQuery,
+                                                    )
+                                            except Exception as e:
+                                                if (
+                                                    datetime.datetime.now()
+                                                    - start_time2
+                                                    > timeout2
+                                                ):
+                                                    break
+                                                time.sleep(1)
+
+                                        print(
+                                            f"{icons.green_dot} Calculated table '{t.Name}' has been created as delta table '{delta_table_name.lower()}' in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
+                                        )
+                                    except:
+                                        print(
+                                            f"{icons.red_dot} Failed to create calculated table '{t.Name}' as a delta table in the lakehouse."
+                                        )
+        except Exception as e:
+            if datetime.datetime.now() - start_time > timeout:
+                break
+            time.sleep(1)
+
+
+@log
+def migrate_field_parameters(
+    dataset: str,
+    new_dataset: str,
+    workspace: Optional[str] = None,
+    new_dataset_workspace: Optional[str] = None,
+):
+    """
+    Migrates field parameters from one semantic model to another.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the import/DirectQuery semantic model.
+    new_dataset : str
+        Name of the Direct Lake semantic model.
+    workspace : str, 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
+        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.
+    """
+
+    from .HelperFunctions import format_dax_object_name
+
+    sempy.fabric._client._utils._init_analysis_services()
+    import Microsoft.AnalysisServices.Tabular as TOM
+
+    if workspace == None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+
+    if new_dataset_workspace == None:
+        new_dataset_workspace = workspace
+
+    dfC = fabric.list_columns(dataset=dataset, workspace=workspace)
+    dfC["Column Object"] = format_dax_object_name(dfC["Table Name"], dfC["Column Name"])
+    dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
+    dfP_filt = dfP[(dfP["Source Type"] == "Calculated")]
+    dfP_filt = dfP_filt[
+        dfP_filt["Query"].str.contains("NAMEOF")
+    ]  # Only field parameters
+    dfC_CalcColumn = dfC[dfC["Type"] == "Calculated"]
+
+    if len(dfP_filt) == 0:
+        print(
+            f"{icons.green_dot} The '{dataset}' semantic model in the '{workspace}' workspace has no field parameters."
+        )
+        return
+
+    start_time = datetime.datetime.now()
+    timeout = datetime.timedelta(minutes=1)
+    success = False
+
+    while not success:
+        try:
+            with connect_semantic_model(
+                dataset=new_dataset, workspace=new_dataset_workspace, readonly=False
+            ) as tom:
+                success = True
+
+                for i, r in dfP_filt.iterrows():
+                    tName = r["Table Name"]
+                    query = r["Query"]
+
+                    # For field parameters, remove calc columns from the query
+                    rows = query.strip().split("\n")
+                    filtered_rows = [
+                        row
+                        for row in rows
+                        if not any(
+                            value in row
+                            for value in dfC_CalcColumn["Column Object"].values
+                        )
+                    ]
+                    updated_query_string = "\n".join(filtered_rows)
+
+                    # Remove extra comma
+                    lines = updated_query_string.strip().split("\n")
+                    lines[-2] = lines[-2].rstrip(",")
+                    expr = "\n".join(lines)
+
+                    try:
+                        par = TOM.Partition()
+                        par.Name = tName
+
+                        parSource = TOM.CalculatedPartitionSource()
+                        par.Source = parSource
+                        parSource.Expression = expr
+
+                        tbl = TOM.Table()
+                        tbl.Name = tName
+                        tbl.Partitions.Add(par)
+
+                        columns = ["Value1", "Value2", "Value3"]
+
+                        for colName in columns:
+                            col = TOM.CalculatedTableColumn()
+                            col.Name = colName
+                            col.SourceColumn = "[" + colName + "]"
+                            col.DataType = TOM.DataType.String
+
+                            tbl.Columns.Add(col)
+
+                        tom.model.Tables.Add(tbl)
+
+                        ep = TOM.JsonExtendedProperty()
+                        ep.Name = "ParameterMetadata"
+                        ep.Value = '{"version":3,"kind":2}'
+
+                        rcd = TOM.RelatedColumnDetails()
+                        gpc = TOM.GroupByColumn()
+                        gpc.GroupingColumn = tom.model.Tables[tName].Columns["Value2"]
+                        rcd.GroupByColumns.Add(gpc)
+
+                        # Update column properties
+                        tom.model.Tables[tName].Columns["Value2"].IsHidden = True
+                        tom.model.Tables[tName].Columns["Value3"].IsHidden = True
+                        tom.model.Tables[tName].Columns[
+                            "Value3"
+                        ].DataType = TOM.DataType.Int64
+                        tom.model.Tables[tName].Columns["Value1"].SortByColumn = (
+                            tom.model.Tables[tName].Columns["Value3"]
+                        )
+                        tom.model.Tables[tName].Columns["Value2"].SortByColumn = (
+                            tom.model.Tables[tName].Columns["Value3"]
+                        )
+                        tom.model.Tables[tName].Columns[
+                            "Value2"
+                        ].ExtendedProperties.Add(ep)
+                        tom.model.Tables[tName].Columns[
+                            "Value1"
+                        ].RelatedColumnDetails = rcd
+
+                        dfC_filt1 = dfC[
+                            (dfC["Table Name"] == tName) & (dfC["Source"] == "[Value1]")
+                        ]
+                        col1 = dfC_filt1["Column Name"].iloc[0]
+                        dfC_filt2 = dfC[
+                            (dfC["Table Name"] == tName) & (dfC["Source"] == "[Value2]")
+                        ]
+                        col2 = dfC_filt2["Column Name"].iloc[0]
+                        dfC_filt3 = dfC[
+                            (dfC["Table Name"] == tName) & (dfC["Source"] == "[Value3]")
+                        ]
+                        col3 = dfC_filt3["Column Name"].iloc[0]
+
+                        tom.model.Tables[tName].Columns["Value1"].Name = col1
+                        tom.model.Tables[tName].Columns["Value2"].Name = col2
+                        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."
+                        )
+                    except:
+                        print(
+                            f"{icons.red_dot} The '{tName}' table has not been added as a field parameter."
+                        )
+        except Exception as e:
+            if datetime.datetime.now() - start_time > timeout:
+                break
+            time.sleep(1)