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

sempy_labs/_model_bpa_rules.py

@@ -8,9 +8,9 @@ from typing import Optional
 
 def model_bpa_rules(
     dataset: str,
-    workspace: Optional[str | None] = None,
-    dependencies: Optional[pd.DataFrame | None] = None,
-):
+    workspace: Optional[str] = None,
+    dependencies: Optional[pd.DataFrame] = None,
+) -> pd.DataFrame:
     """
     Shows the default rules for the semantic model BPA used by the run_model_bpa function.
 
@@ -135,6 +135,17 @@ def model_bpa_rules(
                     "Setting the 'Data Coverage Definition' property may lead to better performance because the engine knows when it can only query the import-portion of the table and when it needs to query the DirectQuery portion of the table.",
                     "https://learn.microsoft.com/analysis-services/tom/table-partitions?view=asallproducts-allversions",
                 ),
+                (
+                    "Performance",
+                    "Model",
+                    "Warning",
+                    "Dual mode is only relevant for dimension tables if DirectQuery is used for the corresponding fact table",
+                    lambda obj: not any(
+                        p.Mode == TOM.ModeType.DirectQuery for p in tom.all_partitions()
+                    )
+                    and any(p.Mode == TOM.ModeType.Dual for p in tom.all_partitions()),
+                    "Only use Dual mode for dimension tables/partitions where a corresponding fact table is in DirectQuery. Using Dual mode in other circumstances (i.e. rest of the model is in Import mode) may lead to performance issues especially if the number of measures in the model is high.",
+                ),
                 (
                     "Performance",
                     "Table",
@@ -413,7 +424,7 @@ def model_bpa_rules(
                         re.search(
                             r"USERELATIONSHIP\s*\(\s*.+?(?=])\]\s*,\s*'*"
                             + obj.Name
-                            + "'*\[",
+                            + r"'*\[",
                             m.Expression,
                             flags=re.IGNORECASE,
                         )
@@ -590,13 +601,13 @@ def model_bpa_rules(
                         re.search(
                             r"USERELATIONSHIP\s*\(\s*\'*"
                             + obj.FromTable.Name
-                            + "'*\["
+                            + r"'*\["
                             + obj.FromColumn.Name
-                            + "\]\s*,\s*'*"
+                            + r"\]\s*,\s*'*"
                             + obj.ToTable.Name
-                            + "'*\["
+                            + r"'*\["
                             + obj.ToColumn.Name
-                            + "\]",
+                            + r"\]",
                             m.Expression,
                             flags=re.IGNORECASE,
                         )

sempy_labs/_model_dependencies.py

@@ -8,7 +8,9 @@ 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.
 
@@ -33,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]
@@ -132,7 +134,9 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
 
 
 @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.
 
@@ -288,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
 
@@ -311,19 +315,17 @@ 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 = icons.measure_icon + " "
+        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 = (
-                icons.column_icon + " '" + 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 = icons.table_icon + " "
+            child_node.custom_property = f"{icons.table_icon} "
         elif ref_obj_type == "Measure":
-            child_node.custom_property = icons.measure_icon + " "
+            child_node.custom_property = f"{icons.measure_icon} "
 
         # Update the dictionary with the child node
         node_dict[child_node_name] = child_node

sempy_labs/_one_lake_integration.py

@@ -50,13 +50,13 @@ def export_model_to_onelake(
     {{
     'export': {{
     'layout': 'delta',
-    'type': 'full',  
-    'objects': [  
-        {{  
+    'type': 'full',
+    'objects': [
+        {{
         'database': '{dataset}'
-        }}  
-    ]  
-    }}  
+        }}
+    ]
+    }}
     }}
     """
 
@@ -120,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",

sempy_labs/_query_scale_out.py

@@ -1,7 +1,10 @@
 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
 
@@ -18,20 +21,11 @@ def qso_sync(dataset: str, workspace: Optional[str] = None):
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
-
-    Returns
-    -------
-
     """
 
     # 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()
@@ -46,7 +40,9 @@ def qso_sync(dataset: str, workspace: Optional[str] = None):
     )
 
 
-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,7 +57,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.
     """
 
     # https://learn.microsoft.com/en-us/rest/api/power-bi/datasets/get-query-scale-out-sync-status-in-group
@@ -84,12 +81,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()
@@ -101,29 +93,29 @@ def qso_sync_status(dataset: str, workspace: Optional[str] = None):
         raise FabricHTTPException(response)
 
     o = response.json()
-    sos = o["scaleOutStatus"]
+    sos = o.get("scaleOutStatus")
 
     if sos == "Enabled":
         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"],
+            "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)
 
-        for r in o["scaleOutReplicas"]:
+        for r in o.get("scaleOutReplicas", []):
             new_data = {
-                "Replica ID": r["replicaId"],
-                "Replica Type": r["replicaType"],
-                "Replica Version": str(r["replicaVersion"]),
-                "Replica Timestamp": r["replicaTimestamp"],
+                "Replica ID": r.get("replicaId"),
+                "Replica Type": r.get("replicaType"),
+                "Replica Version": str(r.get("replicaVersion")),
+                "Replica Timestamp": r.get("replicaTimestamp"),
             }
             dfRep = pd.concat(
                 [dfRep, pd.DataFrame(new_data, index=[0])], ignore_index=True
@@ -147,7 +139,7 @@ def qso_sync_status(dataset: str, workspace: Optional[str] = None):
         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 +154,11 @@ 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"}}
@@ -183,6 +171,7 @@ def disable_qso(dataset: str, workspace: Optional[str] = None):
         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."
     )
@@ -195,7 +184,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.
 
@@ -214,17 +203,13 @@ 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:
@@ -234,31 +219,27 @@ def set_qso(
     request_body = {
         "queryScaleOutSettings": {
             "autoSyncReadOnlyReplicas": auto_sync,
-            "maxReadOnlyReplicas": str(max_read_only_replicas),
+            "maxReadOnlyReplicas": max_read_only_replicas,
         }
     }
 
-    ssm = set_semantic_model_storage_format(
+    set_semantic_model_storage_format(
         dataset=dataset, storage_format="Large", workspace=workspace
     )
-    if ssm == 200:
-        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)
+    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)
 
-        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\""
-        )
+    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
 
 
 def set_semantic_model_storage_format(
@@ -277,18 +258,9 @@ def set_semantic_model_storage_format(
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
-
-    Returns
-    -------
-
     """
 
-    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()
@@ -317,10 +289,10 @@ def set_semantic_model_storage_format(
         raise FabricHTTPException(response)
     print(f"{icons.green_dot} Semantic model storage format set to '{storage_format}'.")
 
-    return 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).
 
@@ -339,11 +311,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)
@@ -360,7 +328,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"
@@ -416,14 +385,10 @@ 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}
 

sempy_labs/_refresh_semantic_model.py

@@ -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
@@ -90,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(
@@ -98,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(

sempy_labs/_translations.py

@@ -1,3 +1,4 @@
+import sempy
 import pandas as pd
 from typing import List, Optional, Union
 from sempy._utils._log import log
@@ -10,7 +11,7 @@ def translate_semantic_model(
     languages: Union[str, List[str]],
     exclude_characters: Optional[str] = None,
     workspace: Optional[str] = None,
-):
+) -> pd.DataFrame:
     """
     Translates names, descriptions, display folders for all objects in a semantic model.
 
@@ -29,6 +30,8 @@ def translate_semantic_model(
 
     Returns
     -------
+    pandas.DataFrame
+        Shows a pandas dataframe which displays all of the translations in the semantic model.
 
     """
 
@@ -302,3 +305,153 @@ def translate_semantic_model(
                                     lang,
                                     i,
                                 )
+    result = pd.DataFrame(
+        columns=[
+            "Language",
+            "Object Type",
+            "Table Name",
+            "Object Name",
+            "Translated Object Name",
+            "Description",
+            "Translated Description",
+            "Display Folder",
+            "Translated Display Folder",
+        ]
+    )
+    with connect_semantic_model(
+        dataset=dataset, readonly=True, workspace=workspace
+    ) as tom:
+
+        sempy.fabric._client._utils._init_analysis_services()
+        import Microsoft.AnalysisServices.Tabular as TOM
+
+        for c in tom.model.Cultures:
+            for tr in c.ObjectTranslations:
+                oType = str(tr.Object.ObjectType)
+                oName = tr.Object.Name
+                tValue = tr.Value
+                prop = str(tr.Property)
+
+                if tr.Object.ObjectType == TOM.ObjectType.Table:
+                    desc = tom.model.Tables[oName].Description
+                    new_data = {
+                        "Language": c.Name,
+                        "Table Name": oName,
+                        "Object Name": oName,
+                        "Object Type": oType,
+                        "Description": desc,
+                    }
+                    result = pd.concat(
+                        [result, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+                    condition = (
+                        (result["Language"] == c.Name)
+                        & (result["Table Name"] == oName)
+                        & (result["Object Name"] == oName)
+                        & (result["Object Type"] == oType)
+                    )
+                elif tr.Object.ObjectType == TOM.ObjectType.Level:
+                    hierarchyName = tr.Object.Parent.Name
+                    tName = tr.Object.Parent.Parent.Name
+                    levelName = "'" + hierarchyName + "'[" + oName + "]"
+                    desc = (
+                        tom.model.Tables[tName]
+                        .Hierarchies[hierarchyName]
+                        .Levels[oName]
+                        .Description
+                    )
+                    new_data = {
+                        "Language": c.Name,
+                        "Table Name": tName,
+                        "Object Name": levelName,
+                        "Object Type": oType,
+                        "Description": desc,
+                    }
+                    result = pd.concat(
+                        [result, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+                    condition = (
+                        (result["Language"] == c.Name)
+                        & (result["Table Name"] == tName)
+                        & (result["Object Name"] == levelName)
+                        & (result["Object Type"] == oType)
+                    )
+                elif tr.Object.ObjectType == TOM.ObjectType.Column:
+                    tName = tr.Object.Table.Name
+                    desc = tom.model.Tables[tName].Columns[oName].Description
+                    display_folder = (
+                        tom.model.Tables[tName].Columns[oName].DisplayFolder
+                    )
+                    new_data = {
+                        "Language": c.Name,
+                        "Table Name": tName,
+                        "Object Name": oName,
+                        "Object Type": oType,
+                        "Description": desc,
+                        "Display Folder": display_folder,
+                    }
+                    result = pd.concat(
+                        [result, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+                    condition = (
+                        (result["Language"] == c.Name)
+                        & (result["Table Name"] == tName)
+                        & (result["Object Name"] == oName)
+                        & (result["Object Type"] == oType)
+                    )
+                elif tr.Object.ObjectType == TOM.ObjectType.Measure:
+                    tName = tr.Object.Table.Name
+                    desc = tom.model.Tables[tName].Measures[oName].Description
+                    display_folder = (
+                        tom.model.Tables[tName].Measures[oName].DisplayFolder
+                    )
+                    new_data = {
+                        "Language": c.Name,
+                        "Table Name": tName,
+                        "Object Name": oName,
+                        "Object Type": oType,
+                        "Description": desc,
+                        "Display Folder": display_folder,
+                    }
+                    result = pd.concat(
+                        [result, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+                    condition = (
+                        (result["Language"] == c.Name)
+                        & (result["Table Name"] == tName)
+                        & (result["Object Name"] == oName)
+                        & (result["Object Type"] == oType)
+                    )
+                elif tr.Object.ObjectType == TOM.ObjectType.Hierarchy:
+                    tName = tr.Object.Table.Name
+                    desc = tom.model.Tables[tName].Hierarchies[oName].Description
+                    display_folder = (
+                        tom.model.Tables[tName].Hierarchies[oName].DisplayFolder
+                    )
+                    new_data = {
+                        "Language": c.Name,
+                        "Table Name": tName,
+                        "Object Name": oName,
+                        "Object Type": oType,
+                        "Description": desc,
+                        "Display Folder": display_folder,
+                    }
+                    result = pd.concat(
+                        [result, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+                    condition = (
+                        (result["Language"] == c.Name)
+                        & (result["Table Name"] == tName)
+                        & (result["Object Name"] == oName)
+                        & (result["Object Type"] == oType)
+                    )
+
+                if prop == "Caption":
+                    result.loc[condition, "Translated Object Name"] = tValue
+                elif prop == "Description":
+                    result.loc[condition, "Translated Description"] = tValue
+                else:
+                    result.loc[condition, "Translated Display Folder"] = tValue
+        result.fillna("", inplace=True)
+
+    return result