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

sempy_labs/directlake/_update_directlake_partition_entity.py

@@ -1,17 +1,18 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs.tom import connect_semantic_model
 from sempy_labs._helper_functions import resolve_lakehouse_name
+from sempy_labs._refresh_semantic_model import refresh_semantic_model
 from typing import List, Optional, Union
 import sempy_labs._icons as icons
 
+
 def update_direct_lake_partition_entity(
     dataset: str,
     table_name: Union[str, List[str]],
     entity_name: Union[str, List[str]],
     workspace: Optional[str] = None,
     lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None
+    lakehouse_workspace: Optional[str] = None,
 ):
     """
     Remaps a table (or tables) in a Direct Lake semantic model to a table in a lakehouse.
@@ -53,22 +54,144 @@ def update_direct_lake_partition_entity(
         entity_name = [entity_name]
 
     if len(table_name) != len(entity_name):
-        raise ValueError(f"{icons.red_dot} The 'table_name' and 'entity_name' arrays must be of equal length.")
+        raise ValueError(
+            f"{icons.red_dot} The 'table_name' and 'entity_name' arrays must be of equal length."
+        )
 
     with connect_semantic_model(
         dataset=dataset, readonly=False, workspace=workspace
     ) as tom:
 
         if not tom.is_direct_lake():
-            raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode.")
+            raise ValueError(
+                f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace is not in Direct Lake mode."
+            )
 
         for tName in table_name:
             i = table_name.index(tName)
             eName = entity_name[i]
-            try:
-                tom.model.Tables[tName].Partitions[0].EntityName = eName
+            part_name = (
+                p.Name
+                for t in tom.model.Tables
+                for p in t.Partitions
+                if t.Name == tName
+            )
+
+            if part_name is None:
+                raise ValueError(
+                    f"{icons.red_dot} The '{tName}' table in the '{dataset}' semantic model has not been updated."
+                )
+            else:
+                tom.model.Tables[tName].Partitions[part_name].EntityName = eName
                 print(
-                    f"{icons.green_dot} The '{tName}' table in the '{dataset}' semantic model has been updated to point to the '{eName}' table in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
+                    f"{icons.green_dot} The '{tName}' table in the '{dataset}' semantic model has been updated to point to the '{eName}' table "
+                    f"in the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace."
                 )
-            except Exception as e:
-                raise ValueError(f"{icons.red_dot} The '{tName}' table in the '{dataset}' semantic model has not been updated.") from e
+
+
+def add_table_to_direct_lake_semantic_model(
+    dataset: str,
+    table_name: str,
+    lakehouse_table_name: str,
+    workspace: Optional[str | None] = None,
+):
+    """
+    Adds a table and all of its columns to a Direct Lake semantic model, based on a Fabric lakehouse table.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    table_name : str, List[str]
+        Name of the table in the semantic model.
+    lakehouse_table_name : str
+        The name of the Fabric lakehouse table.
+    workspace : str, default=None
+        The name of the Fabric workspace in which the semantic model 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.
+
+    Returns
+    -------
+    """
+
+    import Microsoft.AnalysisServices.Tabular as TOM
+    from sempy_labs.lakehouse._get_lakehouse_columns import get_lakehouse_columns
+    from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
+    from sempy_labs.directlake._get_directlake_lakehouse import (
+        get_direct_lake_lakehouse,
+    )
+
+    workspace = fabric.resolve_workspace_name(workspace)
+
+    with connect_semantic_model(
+        dataset=dataset, readonly=False, workspace=workspace
+    ) as tom:
+
+        if tom.is_direct_lake() is False:
+            raise ValueError(
+                "This function is only valid for Direct Lake semantic models."
+            )
+
+        if any(
+            p.Name == lakehouse_table_name
+            for p in tom.all_partitions()
+            if p.SourceType == TOM.PartitionSourceType.Entity
+        ):
+            t_name = next(
+                p.Parent.Name
+                for p in tom.all_partitions()
+                if p.Name
+                == lakehouse_table_name & p.SourceType
+                == TOM.PartitionSourceType.Entity
+            )
+            raise ValueError(
+                f"The '{lakehouse_table_name}' table already exists in the '{dataset}' semantic model within the '{workspace}' workspace as the '{t_name}' table."
+            )
+
+        if any(t.Name == table_name for t in tom.model.Tables):
+            raise ValueError(
+                f"The '{table_name}' table already exists in the '{dataset}' semantic model within the '{workspace}' workspace."
+            )
+
+        lake_name, lake_id = get_direct_lake_lakehouse(
+            dataset=dataset, workspace=workspace
+        )
+
+        dfL = get_lakehouse_tables(lakehouse=lake_name, workspace=workspace)
+        dfL_filt = dfL[dfL["Table Name"] == lakehouse_table_name]
+
+        if len(dfL_filt) == 0:
+            raise ValueError(
+                f"The '{lakehouse_table_name}' table does not exist in the '{lake_name}' lakehouse within the '{workspace}' workspace."
+            )
+
+        dfLC = get_lakehouse_columns(lakehouse=lake_name, workspace=workspace)
+        dfLC_filt = dfLC[dfLC["Table Name"] == lakehouse_table_name]
+
+        tom.add_table(name=table_name)
+        print(
+            f"{icons.green_dot} The '{table_name}' table has been added to the '{dataset}' semantic model within the '{workspace}' workspace."
+        )
+        tom.add_entity_partition(
+            table_name=table_name, entity_name=lakehouse_table_name
+        )
+        print(
+            f"{icons.green_dot} The '{lakehouse_table_name}' partition has been added to the '{table_name}' table in the '{dataset}' semantic model within the '{workspace}' workspace."
+        )
+
+        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=table_name,
+                column_name=lakeCName,
+                source_column=lakeCName,
+                data_type=dt,
+            )
+            print(
+                f"{icons.green_dot} The '{lakeCName}' column has been added to the '{table_name}' table as a '{dt}' data type in the '{dataset}' semantic model within the '{workspace}' workspace."
+            )
+
+        refresh_semantic_model(dataset=dataset, tables=table_name, workspace=workspace)

sempy_labs/directlake/_warm_cache.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from tqdm.auto import tqdm
@@ -45,7 +44,9 @@ def warm_direct_lake_cache_perspective(
 
     dfP = fabric.list_partitions(dataset=dataset, workspace=workspace)
     if not any(r["Mode"] == "DirectLake" for i, r in dfP.iterrows()):
-        raise ValueError(f"{icons.red_dot} The '{dataset}' semantic model in the '{workspace}' workspace is not in Direct Lake mode. This function is specifically for semantic models in Direct Lake mode.")
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset}' semantic model in the '{workspace}' workspace is not in Direct Lake mode. This function is specifically for semantic models in Direct Lake mode."
+        )
 
     dfPersp = fabric.list_perspectives(dataset=dataset, workspace=workspace)
     dfPersp["DAX Object Name"] = format_dax_object_name(
@@ -54,7 +55,9 @@ def warm_direct_lake_cache_perspective(
     dfPersp_filt = dfPersp[dfPersp["Perspective Name"] == perspective]
 
     if len(dfPersp_filt) == 0:
-        raise ValueError(f"{icons.red_dot} The '{perspective} perspective does not exist or contains no objects within the '{dataset}' semantic model in the '{workspace}' workspace.")
+        raise ValueError(
+            f"{icons.red_dot} The '{perspective} perspective does not exist or contains no objects within the '{dataset}' semantic model in the '{workspace}' workspace."
+        )
 
     dfPersp_c = dfPersp_filt[dfPersp_filt["Object Type"] == "Column"]
 

sempy_labs/lakehouse/_get_lakehouse_columns.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from pyspark.sql import SparkSession
@@ -10,6 +9,7 @@ from sempy_labs._helper_functions import (
 from typing import Optional
 from sempy._utils._log import log
 
+
 @log
 def get_lakehouse_columns(
     lakehouse: Optional[str] = None, workspace: Optional[str] = None

sempy_labs/lakehouse/_get_lakehouse_tables.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from pyspark.sql import SparkSession
@@ -18,6 +17,7 @@ from typing import Optional
 import sempy_labs._icons as icons
 from sempy._utils._log import log
 
+
 @log
 def get_lakehouse_tables(
     lakehouse: Optional[str] = None,
@@ -174,8 +174,10 @@ def get_lakehouse_tables(
     if export:
         lakeAttach = lakehouse_attached()
         if lakeAttach is False:
-            raise ValueError(f"{icons.red_dot} In order to save the report.json file, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook.")
-            
+            raise ValueError(
+                f"{icons.red_dot} In order to save the report.json file, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
+            )
+
         spark = SparkSession.builder.getOrCreate()
 
         lakehouse_id = fabric.get_lakehouse_id()

sempy_labs/lakehouse/_lakehouse.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 from tqdm.auto import tqdm
 from pyspark.sql import SparkSession
@@ -7,6 +6,7 @@ from typing import List, Optional, Union
 import sempy_labs._icons as icons
 from sempy._utils._log import log
 
+
 def lakehouse_attached() -> bool:
     """
     Identifies if a lakehouse is attached to the notebook.
@@ -25,6 +25,7 @@ def lakehouse_attached() -> bool:
     else:
         return False
 
+
 @log
 def optimize_lakehouse_tables(
     tables: Optional[Union[str, List[str]]] = None,

sempy_labs/lakehouse/_shortcuts.py

@@ -1,4 +1,3 @@
-import sempy
 import sempy.fabric as fabric
 from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
@@ -7,6 +6,7 @@ from sempy_labs._helper_functions import (
 )
 from typing import Optional
 import sempy_labs._icons as icons
+from sempy.fabric.exceptions import FabricHTTPException
 
 
 def create_shortcut_onelake(
@@ -74,12 +74,15 @@ def create_shortcut_onelake(
         )
         if response.status_code == 201:
             print(
-                f"{icons.green_dot} The shortcut '{shortcut_name}' was created in the '{destination_lakehouse}' lakehouse within the '{destination_workspace} workspace. It is based on the '{table_name}' table in the '{source_lakehouse}' lakehouse within the '{source_workspace}' workspace."
+                f"{icons.green_dot} The shortcut '{shortcut_name}' was created in the '{destination_lakehouse}' lakehouse within"
+                f" the '{destination_workspace} workspace. It is based on the '{table_name}' table in the '{source_lakehouse}' lakehouse within the '{source_workspace}' workspace."
             )
         else:
             print(response.status_code)
     except Exception as e:
-        raise ValueError(f"{icons.red_dot} Failed to create a shortcut for the '{table_name}' table.") from e
+        raise ValueError(
+            f"{icons.red_dot} Failed to create a shortcut for the '{table_name}' table."
+        ) from e
 
 
 def create_shortcut(
@@ -114,7 +117,9 @@ def create_shortcut(
     sourceValues = list(source_titles.keys())
 
     if source not in sourceValues:
-        raise ValueError(f"{icons.red_dot} The 'source' parameter must be one of these values: {sourceValues}.")
+        raise ValueError(
+            f"{icons.red_dot} The 'source' parameter must be one of these values: {sourceValues}."
+        )
 
     sourceTitle = source_titles[source]
 
@@ -147,12 +152,15 @@ def create_shortcut(
         )
         if response.status_code == 201:
             print(
-                f"{icons.green_dot} The shortcut '{shortcutActualName}' was created in the '{lakehouse}' lakehouse within the '{workspace} workspace. It is based on the '{subpath}' table in '{sourceTitle}'."
+                f"{icons.green_dot} The shortcut '{shortcutActualName}' was created in the '{lakehouse}' lakehouse within"
+                f" the '{workspace} workspace. It is based on the '{subpath}' table in '{sourceTitle}'."
             )
         else:
             print(response.status_code)
     except Exception as e:
-        raise ValueError(f"{icons.red_dot} Failed to create a shortcut for the '{shortcut_name}' table.") from e
+        raise ValueError(
+            f"{icons.red_dot} Failed to create a shortcut for the '{shortcut_name}' table."
+        ) from e
 
 
 def delete_shortcut(
@@ -187,9 +195,8 @@ def delete_shortcut(
         f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts/Tables/{shortcut_name}"
     )
 
-    if response.status_code == 200:
-        print(
-            f"{icons.green_dot} The '{shortcut_name}' shortcut in the '{lakehouse}' within the '{workspace}' workspace has been deleted."
-        )
-    else:
-        raise ValueError(f"{icons.red_dot} The '{shortcut_name}' has not been deleted.")
+    if response.status_code != 200:
+        raise FabricHTTPException(response)
+    print(
+        f"{icons.green_dot} The '{shortcut_name}' shortcut in the '{lakehouse}' within the '{workspace}' workspace has been deleted."
+    )

sempy_labs/migration/__init__.py

@@ -27,5 +27,5 @@ __all__ = [
     "migrate_model_objects_to_semantic_model",
     "migrate_tables_columns_to_semantic_model",
     "migration_validation",
-    "refresh_calc_tables"
+    "refresh_calc_tables",
 ]

sempy_labs/migration/_create_pqt_file.py

@@ -1,6 +1,7 @@
-import sempy
 import sempy.fabric as fabric
-import json, os, shutil
+import json
+import os
+import shutil
 import xml.etree.ElementTree as ET
 from sempy_labs._list_functions import list_tables
 from sempy_labs.lakehouse._lakehouse import lakehouse_attached
@@ -11,10 +12,13 @@ import sempy_labs._icons as icons
 
 @log
 def create_pqt_file(
-    dataset: str, workspace: Optional[str] = None, file_name: Optional[str] = 'PowerQueryTemplate'
+    dataset: str,
+    workspace: Optional[str] = None,
+    file_name: Optional[str] = "PowerQueryTemplate",
 ):
     """
-    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.
+    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
     ----------
@@ -31,7 +35,9 @@ def create_pqt_file(
     lakeAttach = lakehouse_attached()
 
     if lakeAttach is False:
-        raise ValueError(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.")
+        raise ValueError(
+            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."
+        )
 
     workspace = fabric.resolve_workspace_name(workspace)
 
@@ -188,16 +194,16 @@ def create_pqt_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"},
-        )
+        # 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)

sempy_labs/migration/_migrate_calctables_to_lakehouse.py

@@ -1,7 +1,9 @@
 import sempy
 import sempy.fabric as fabric
 import pandas as pd
-import re, datetime, time
+import re
+import datetime
+import time
 from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
 from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
@@ -10,7 +12,7 @@ from sempy_labs._helper_functions import (
 )
 from sempy_labs.tom import connect_semantic_model
 from pyspark.sql import SparkSession
-from typing import List, Optional, Union
+from typing import Optional
 from sempy._utils._log import log
 import sempy_labs._icons as icons
 
@@ -25,7 +27,8 @@ def migrate_calc_tables_to_lakehouse(
     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.
+    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
     ----------
@@ -67,8 +70,6 @@ def migrate_calc_tables_to_lakehouse(
     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[
@@ -113,7 +114,8 @@ def migrate_calc_tables_to_lakehouse(
                 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."
+                            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:
@@ -182,7 +184,7 @@ def migrate_calc_tables_to_lakehouse(
                                                     == "CalculatedTableColumn"
                                                     and c.SourceColumn == col
                                                 )
-                                            except:
+                                            except Exception:
                                                 dataType = next(
                                                     str(c.DataType)
                                                     for c in tom.model.Tables[
@@ -240,7 +242,7 @@ def migrate_calc_tables_to_lakehouse(
                                                         name=t.Name,
                                                         value=daxQuery,
                                                     )
-                                            except Exception as e:
+                                            except Exception:
                                                 if (
                                                     datetime.datetime.now()
                                                     - start_time2
@@ -250,13 +252,14 @@ def migrate_calc_tables_to_lakehouse(
                                                 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."
+                                            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."
                                         )
-                                    except:
+                                    except Exception:
                                         print(
                                             f"{icons.red_dot} Failed to create calculated table '{t.Name}' as a delta table in the lakehouse."
                                         )
-        except Exception as e:
+        except Exception:
             if datetime.datetime.now() - start_time > timeout:
                 break
             time.sleep(1)
@@ -419,11 +422,11 @@ def migrate_field_parameters(
                         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:
+                    except Exception:
                         print(
                             f"{icons.red_dot} The '{tName}' table has not been added as a field parameter."
                         )
-        except Exception as e:
+        except Exception:
             if datetime.datetime.now() - start_time > timeout:
                 break
             time.sleep(1)

sempy_labs/migration/_migrate_calctables_to_semantic_model.py

@@ -1,8 +1,9 @@
-import sempy
 import sempy.fabric as fabric
-import re, datetime, time
+import re
+import datetime
+import time
 from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
-from sempy_labs._helper_functions import resolve_lakehouse_name
+from sempy_labs._helper_functions import resolve_lakehouse_name, format_dax_object_name
 from sempy_labs.tom import connect_semantic_model
 from typing import Optional
 from sempy._utils._log import log
@@ -66,7 +67,7 @@ def migrate_calc_tables_to_semantic_model(
     dfC_filt = dfC[
         (dfC["Table Name"].isin(dfP_filt["Table Name"]))
     ]  # & (dfC['Type'] == 'CalculatedTableColumn')]
-    # dfA = list_annotations(new_dataset, new_dataset_workspace)
+    # dfA = fabric.list_annotations(new_dataset, new_dataset_workspace)
     # dfA_filt = dfA[(dfA['Object Type'] == 'Model') & ~ (dfA['Annotation Value'].str.contains('NAMEOF'))]
 
     if len(dfP_filt) == 0:
@@ -87,10 +88,7 @@ def migrate_calc_tables_to_semantic_model(
                 success = True
                 for tName in dfC_filt["Table Name"].unique():
                     if tName.lower() in lc["Table Name"].values:
-
-                        try:
-                            tom.model.Tables[tName]
-                        except:
+                        if not any(t.Name == tName for t in tom.model.Tables):
                             tom.add_table(name=tName)
                             tom.add_entity_partition(
                                 table_name=tName,
@@ -112,11 +110,11 @@ def migrate_calc_tables_to_semantic_model(
                             & (dfC["Column Name"] == cName),
                             "Data Type",
                         ].iloc[0]
-                        cType = dfC.loc[
-                            (dfC["Table Name"] == tName)
-                            & (dfC["Column Name"] == cName),
-                            "Type",
-                        ].iloc[0]
+                        # cType = dfC.loc[
+                        #    (dfC["Table Name"] == tName)
+                        #    & (dfC["Column Name"] == cName),
+                        #    "Type",
+                        # ].iloc[0]
 
                         # av = tom.get_annotation_value(object = tom.model, name = tName)
 
@@ -127,9 +125,10 @@ def migrate_calc_tables_to_semantic_model(
 
                         matches = re.findall(pattern, scName)
                         lakeColumn = matches[0].replace(" ", "")
-                        try:
-                            tom.model.Tables[tName].Columns[cName]
-                        except:
+                        if not any(
+                            c.Name == cName and c.Parent.Name == tName
+                            for c in tom.all_columns()
+                        ):
                             tom.add_data_column(
                                 table_name=tName,
                                 column_name=cName,
@@ -137,14 +136,14 @@ def migrate_calc_tables_to_semantic_model(
                                 data_type=cDataType,
                             )
                             print(
-                                f"{icons.green_dot} The '{tName}'[{cName}] column has been added."
+                                f"{icons.green_dot} The {format_dax_object_name(tName,cName)} column has been added."
                             )
 
                 print(
                     f"\n{icons.green_dot} All viable calculated tables have been added to the model."
                 )
 
-        except Exception as e:
+        except Exception:
             if datetime.datetime.now() - start_time > timeout:
                 break
             time.sleep(1)