qe-api-client 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

qe_api_client/engine.py

@@ -1,3 +1,5 @@
+import json
+
 import qe_api_client.api_classes.engine_app_api as engine_app_api
 import qe_api_client.engine_communicator as engine_communicator
 import qe_api_client.api_classes.engine_field_api as engine_field_api
@@ -93,8 +95,14 @@ class QixEngine:
         fld_handle = self.get_handle(lb_field)
         return self.efa.clear(fld_handle)
 
+
     def create_single_master_dimension(self, app_handle: int, dim_title: str, dim_def: str, dim_label: str = "",
-                                       dim_desc: str = "", dim_tags: list = None):
+                                       dim_desc: str = "", dim_tags: list = None, dim_color: str = None,
+                                       dim_color_index: int = -1, value_colors: list = None,
+                                       null_value_color: str = None, null_value_color_index: int = -1,
+                                       other_value_color: str = None, other_value_color_index: int = -1,
+                                       single_color: str = None, single_color_index: int = -1, palette: str = None
+                                       ):
         """
         Creates a single master dimension.
 
@@ -105,22 +113,105 @@ class QixEngine:
             dim_label (str, optional): The label of the dimension.
             dim_desc (str, optional): The description of the dimension.
             dim_tags (list, optional): The tags of the dimension.
+            dim_color (str, optional): The master dimension color.
+            dim_color_index (int, optional): The index of the master dimension color in the theme color picker.
+            value_colors (list, optional): The value colors of the master dimension.
+            null_value_color (str, optional): The NULL value color of the master dimension.
+            null_value_color_index (int, optional): The index of the NULL value color of the master dimension in the theme color picker.
+            other_value_color (str, optional): The OTHER value color of the master dimension.
+            other_value_color_index (int, optional): The index of the OTHER value color of the master dimension in the theme color picker.
+            single_color (str, optional): Single color of the values of the master dimension.
+            single_color_index (int, optional): The index of single color of the values of the master dimension in the theme color picker.
+            palette (str, optional): Choose a color palette, if there are more than one.
 
         Returns:
             dict: The handle and Id of the dimension.
         """
+        if value_colors is None:
+            value_colors = []
         if dim_tags is None:
             dim_tags = []
+
+        # Define of the single dimension properties
         nx_info = self.structs.nx_info(obj_type="dimension")
+        if dim_color is None:
+            coloring = self.structs.coloring()
+        else:
+            coloring = self.structs.coloring(base_color={"color": dim_color, "index": dim_color_index})
+
         nx_library_dimension_def = self.structs.nx_library_dimension_def(grouping="N", field_definitions=[dim_def],
                                                                          field_labels=[dim_title],
-                                                                         label_expression=dim_label)
+                                                                         label_expression=dim_label, alias=dim_title,
+                                                                         title=dim_title, coloring=coloring)
         gen_dim_props = self.structs.generic_dimension_properties(nx_info=nx_info,
                                                                   nx_library_dimension_def=nx_library_dimension_def,
                                                                   title=dim_title, description=dim_desc, tags=dim_tags)
+
+        # Create the single dimension
         master_dim = self.eaa.create_dimension(app_handle, gen_dim_props)
+
+        # Get id and handle of the master dimension
+        master_dim_id = self.get_id(master_dim)
+        master_dim_handle = self.get_handle(master_dim)
+
+        # Update "colorMapRef" property with the master dimension id.
+        patch_value = json.dumps(master_dim_id)
+        patch_color_map_ref = self.structs.nx_patch(op="replace", path="/qDim/coloring/colorMapRef", value=patch_value)
+        self.egda.apply_patches(handle=master_dim_handle, patches=[patch_color_map_ref])
+
+        # Define the color properties
+        if null_value_color is None:
+            null_value = None
+        else:
+            null_value = {"color": null_value_color, "index": null_value_color_index}
+
+        if other_value_color is None:
+            other_value = None
+        else:
+            other_value = {"color": other_value_color, "index": other_value_color_index}
+
+        if single_color is None:
+            single = None
+        else:
+            single = {"color": single_color, "index": single_color_index}
+
+        colors = value_colors
+        color_map = self.structs.color_map(colors=colors, nul=null_value, oth=other_value, single=single, pal=palette)
+        color_map_props = self.structs.color_map_properties(dim_id=master_dim_id, _color_map=color_map)
+
+        # Create color map object, if colors are passed.
+        if value_colors or null_value_color is not None or other_value_color is not None or single_color is not None or palette is not None:
+            color_map_model = self.eaa.create_object(app_handle, color_map_props)
+            color_map_model_handle = self.get_handle(color_map_model)
+
+            # Set "autoFill" and "usePal" to "False", if a single color is passed.
+            if bool(single):
+                patch_value_use_pal_auto_fill = json.dumps(False)
+                patch_use_pal = self.structs.nx_patch(op="replace", path="/colorMap/usePal",
+                                                      value=patch_value_use_pal_auto_fill)
+                self.egda.apply_patches(handle=color_map_model_handle, patches=[patch_use_pal])
+
+                patch_auto_fill = self.structs.nx_patch(op="replace", path="/colorMap/autoFill",
+                                                      value=patch_value_use_pal_auto_fill)
+                self.egda.apply_patches(handle=color_map_model_handle, patches=[patch_auto_fill])
+
+            # Set "autoFill" to "False", if a color palette is passed.
+            if palette is not None:
+                patch_value_auto_fill = json.dumps(False)
+                patch_auto_fill = self.structs.nx_patch(op="replace", path="/colorMap/autoFill",
+                                                        value=patch_value_auto_fill)
+                self.egda.apply_patches(handle=color_map_model_handle, patches=[patch_auto_fill])
+
+        # Update "hasValueColors" property, if value colors are passed.
+        if value_colors:
+            patch_value_has_value_colors = json.dumps(True)
+            patch_has_value_colors = self.structs.nx_patch(op="replace", path="/qDim/coloring/hasValueColors",
+                                                        value=patch_value_has_value_colors)
+            self.egda.apply_patches(handle=master_dim_handle, patches=[patch_has_value_colors])
+
         return master_dim
 
+
     def create_master_measure(self, app_handle: int, mes_title: str, mes_def: str, mes_label: str = "",
                               mes_desc: str = "", mes_tags: list = None):
         """
@@ -139,15 +230,215 @@ class QixEngine:
         """
         if mes_tags is None:
             mes_tags = []
+
+        # Define of the measure properties
         nx_info = self.structs.nx_info(obj_type="measure")
         nx_library_measure_def = self.structs.nx_library_measure_def(label=mes_title, mes_def=mes_def,
                                                                      label_expression=mes_label)
         gen_mes_props = self.structs.generic_measure_properties(nx_info=nx_info,
                                                                 nx_library_measure_def=nx_library_measure_def,
                                                                 title=mes_title, description=mes_desc, tags=mes_tags)
+
+        # Create the measure
         master_mes = self.eaa.create_measure(app_handle, gen_mes_props)
+
         return master_mes
 
+    def create_sheet(self, app_handle: int, sheet_title: str, sheet_desc: str = "", no_of_rows: int = 18):
+        """
+        Creates a sheet.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+            sheet_title (str): The title of the sheet.
+            sheet_desc (str, optional): The description of the sheet.
+            no_of_rows (int, optional): TThe number of the sheet rows. Min. 8 rows and max. 42 rows.
+
+        Returns:
+            dict: The handle and Id of the sheet.
+        """
+        # Define of the sheet properties
+        nx_info = self.structs.nx_info(obj_type="sheet")
+        sheet_def = {"title": sheet_title, "description": sheet_desc}
+        sheet_props = self.structs.generic_object_properties(info=nx_info, prop_name="qMetaDef", prop_def=sheet_def)
+
+        # Add row and column attributes. The number of the row should be between 8 and 42.
+        if no_of_rows not in range(8, 43):
+            no_of_rows = 18
+        no_of_columns = no_of_rows * 2
+
+        # Derive the grid_resolution property
+        if no_of_rows == 12:
+            grid_resolution = "small"
+        elif no_of_rows == 15:
+            grid_resolution = "medium"
+        elif no_of_rows == 18:
+            grid_resolution = "large"
+        else:
+            grid_resolution = "customrows"
+
+        # Add new properties
+        sheet_props.update(
+            {
+                "thumbnail": {"qStaticContentUrlDef": {"qUrl": ""}}, "columns": no_of_columns, "rows": no_of_rows,
+                "customRowBase": no_of_rows, "gridResolution": grid_resolution, "layoutOptions": {"mobileLayout": "LIST"},
+                "qChildListDef": {"qData": {"title": "/title"}}
+            }
+        )
+
+        # Create the sheet
+        sheet = self.eaa.create_object(app_handle, sheet_props)
+
+        return sheet
+
+    def create_list_object(self, handle: int, dim_id: str = "", field_def: str = "", field_title: str = ""):
+        """
+        Creates a list object.
+
+        Parameters:
+            handle (int): The handle of the parent object.
+            dim_id (str, optional): The ID of the master dimension. Let this parameter empty, if you passed the "field_def".
+            field_def (str, optional): The definition of the field. Let this parameter empty, if you passed the "dim_id".
+            field_title (int, optional): The title of the field. Let this parameter empty, if you passed the "dim_id".
+
+        Returns:
+            dict: The handle and Id of the list object.
+        """
+        if field_def is None:
+            field_def = []
+
+        nx_info = self.structs.nx_info(obj_type="listbox")
+        sort_criterias = self.structs.sort_criteria()
+
+        nx_library_dimension_def = self.structs.nx_inline_dimension_def(grouping="N", field_definitions=[field_def],
+                                                                          field_labels=[field_def],
+                                                                          sort_criterias=[sort_criterias])
+        list_object_def = self.structs.list_object_def(library_id=dim_id, definition=nx_library_dimension_def)
+        list_object_props = self.structs.generic_object_properties(info=nx_info, prop_name="qListObjectDef",
+                                                                   prop_def=list_object_def)
+        list_object_props.update(
+            {"showTitles": True, "title": field_title, "subtitle": "", "footnote": "", "disableNavMenu": False,
+             "showDetails": True, "showDetailsExpression": False, "visualization": "listbox"})
+        list_object = self.egoa.create_child(handle=handle, prop=list_object_props)
+
+        return list_object
+
+    def create_filterpane_frame(self, handle: int, no_of_rows_sheet: int, col: int, row: int, colspan: int, rowspan: int):
+        """
+        Creates a filterpane frame.
+
+        Parameters:
+            handle (int): The handle of the parent object.
+            no_of_rows_sheet (int): The number of the sheet rows.
+            col (int): First column the filterpane visualisation starts.
+            row (int): First row the filterpane visualisation starts.
+            colspan (int): The width of the filterpane in columns.
+            rowspan (int): The height of the filterpane in rows.
+
+        Returns:
+            dict: The handle and Id of the filterpane frame.
+        """
+        nx_info = self.structs.nx_info(obj_type="filterpane")
+        filterpane_props = self.structs.generic_object_properties(info=nx_info, prop_name="qMetaDef")
+        filterpane_props.update({"qChildListDef": {"qData": {}}})
+        filterpane = self.egoa.create_child(handle=handle, prop=filterpane_props)
+
+        filterpane_id = self.get_id(filterpane)
+
+        no_of_cols_sheet = no_of_rows_sheet * 2
+        width = colspan / no_of_cols_sheet * 100
+        height = rowspan / no_of_rows_sheet * 100
+        y = row / no_of_rows_sheet * 100
+        x = col / no_of_cols_sheet * 100
+
+        if col >= 0 and colspan > 0 and no_of_cols_sheet >= col + colspan and row >= 0 and rowspan > 0 and no_of_rows_sheet >= row + rowspan:
+            filterpane_layout = self.structs.object_position_size(obj_id=filterpane_id, obj_type="filterpane",
+                                                                         col=col, row=row, colspan=colspan,
+                                                                         rowspan=rowspan, y=y, x=x, width=width,
+                                                                         height=height)
+
+            sheet_layout = self.egoa.get_layout(handle=handle)
+
+            if "cells" not in sheet_layout:
+                patch_value = str([filterpane_layout]).replace("'", "\"")
+                patch_cell = self.structs.nx_patch(op="add", path="/cells", value=patch_value)
+            else:
+                cells = sheet_layout["cells"]
+                cells.append(filterpane_layout)
+                patch_value = str(cells).replace("'", "\"")
+                patch_cell = self.structs.nx_patch(op="replace", path="/cells", value=patch_value)
+
+            self.egoa.apply_patches(handle=handle, patches=[patch_cell])
+        else:
+            print("The position of filterpane \"" + filterpane_id + "\" is out of range. This one will not be created.")
+
+        return filterpane
+
+
+    def create_chart(self, handle: int, obj_type: str, hypercube_def: dict, no_of_rows_sheet: int, col: int, row: int,
+                     colspan: int, rowspan: int):
+        """
+        Creates a chart object.
+
+        Parameters:
+            handle (int): The handle of the parent object.
+            obj_type (str): The type of the chart.
+            hypercube_def (dict): Chart hypercube definition.
+            no_of_rows_sheet (int): The number of the sheet rows.
+            col (int): First column the chart visualisation starts.
+            row (int): First row the chart visualisation starts.
+            colspan (int): The width of the chart in columns.
+            rowspan (int): The height of the chart in rows.
+
+        Returns:
+            dict: The handle and Id of the filterpane frame.
+        """
+
+        nx_info = self.structs.nx_info(obj_type=obj_type)
+        if obj_type == "table":
+            chart_props = self.structs.table_properties(info=nx_info, hypercube_def=hypercube_def)
+        elif obj_type == "sn-table":
+            chart_props = self.structs.sn_table_properties(info=nx_info, hypercube_def=hypercube_def)
+        elif obj_type == "pivot-table":
+            chart_props = self.structs.pivot_table_properties(info=nx_info, hypercube_def=hypercube_def)
+        elif obj_type == "sn-pivot-table":
+            chart_props = self.structs.pivot_table_properties(info=nx_info, hypercube_def=hypercube_def)
+        else:
+            print("Not valid object type.")
+
+        chart = self.egoa.create_child(handle=handle, prop=chart_props)
+
+        chart_id = self.get_id(chart)
+
+        no_of_cols_sheet = no_of_rows_sheet * 2
+        width = colspan / no_of_cols_sheet * 100
+        height = rowspan / no_of_rows_sheet * 100
+        y = row / no_of_rows_sheet * 100
+        x = col / no_of_cols_sheet * 100
+
+        if col >= 0 and colspan > 0 and no_of_cols_sheet >= col + colspan and row >= 0 and rowspan > 0 and no_of_rows_sheet >= row + rowspan:
+            chart_layout = self.structs.object_position_size(obj_id=chart_id, obj_type=obj_type, col=col, row=row,
+                                                             colspan=colspan, rowspan=rowspan, y=y, x=x, width=width,
+                                                             height=height)
+
+            sheet_layout = self.egoa.get_layout(handle=handle)
+
+            if "cells" not in sheet_layout:
+                patch_value = str([chart_layout]).replace("'", "\"")
+                patch_cell = self.structs.nx_patch(op="add", path="/cells", value=patch_value)
+            else:
+                cells = sheet_layout["cells"]
+                cells.append(chart_layout)
+                patch_value = str(cells).replace("'", "\"")
+                patch_cell = self.structs.nx_patch(op="replace", path="/cells", value=patch_value)
+
+            self.egoa.apply_patches(handle=handle, patches=[patch_cell])
+        else:
+            print("The position of chart \"" + chart_id + "\" is out of range. This one will not be created.")
+
+        return chart
+
+
     def get_app_lineage_info(self, app_handle):
         """
         Gets the lineage information of the app. The lineage information includes the LOAD and STORE statements from
@@ -190,6 +481,26 @@ class QixEngine:
         except ValueError:
             return "Bad handle value in " + obj
 
+    @staticmethod
+    def get_id(obj):
+        """
+        Retrieves the id from a given object.
+
+        Parameters:
+        obj : dict
+            The object containing the handle.
+
+        Returns:
+        int: The handle value.
+
+        Raises:
+        ValueError: If the handle value is invalid.
+        """
+        try:
+            return obj["qGenericId"]
+        except ValueError:
+            return "Bad id value in " + obj
+
     def get_chart_data(self, app_handle, obj_id):
         """
         Retrieves the data from a given chart object.
@@ -355,7 +666,7 @@ class QixEngine:
             hc_mes.append(self.structs.nx_measure(library_id=measure))
 
         # Create hypercube structure
-        hc_def = self.structs.hypercube_def(state_name="$", nx_dims=hc_dim, nx_meas=hc_mes)
+        hc_def = self.structs.hypercube_def(state_name="$", dimensions=hc_dim, measures=hc_mes)
 
         # Create info structure
         nx_info = self.structs.nx_info(obj_type="table")
@@ -542,39 +853,39 @@ class QixEngine:
             df_dimension_list.loc[len(df_dimension_list)] = dim_layout
 
         # Resolve the dictionary structure of attribute "qInfo"
-        df_dimension_list_expanded = (df_dimension_list["qInfo"].apply(pd.Series).add_prefix("qInfo_"))
+        df_dimension_list_expanded = (df_dimension_list["qInfo"].dropna().apply(pd.Series).add_prefix("qInfo_"))
         df_dimension_list = df_dimension_list.drop(columns=["qInfo"]).join(df_dimension_list_expanded)
 
         # Resolve the dictionary structure of attribute "qMeta"
-        df_dimension_list_expanded = (df_dimension_list["qMeta"].apply(pd.Series).add_prefix("qMeta_"))
+        df_dimension_list_expanded = (df_dimension_list["qMeta"].dropna().apply(pd.Series).add_prefix("qMeta_"))
         df_dimension_list = df_dimension_list.drop(columns=["qMeta"]).join(df_dimension_list_expanded)
 
         # Resolve the dictionary structure of attribute "qDim"
-        df_dimension_list_expanded = (df_dimension_list["qDim"].apply(pd.Series).add_prefix("qDim_"))
+        df_dimension_list_expanded = (df_dimension_list["qDim"].dropna().apply(pd.Series).add_prefix("qDim_"))
         df_dimension_list = df_dimension_list.drop(columns=["qDim"]).join(df_dimension_list_expanded)
 
         # Resolve the dictionary structure of attribute "qDim_coloring"
         try:
             df_dimension_list_expanded = (
-                df_dimension_list["qDim_coloring"].apply(pd.Series).add_prefix("qDim_coloring_"))
+                df_dimension_list["qDim_coloring"].dropna().apply(pd.Series).add_prefix("qDim_coloring_"))
             df_dimension_list = df_dimension_list.drop(columns=["qDim_coloring"]).join(df_dimension_list_expanded)
         except KeyError:
-            df_dimension_list["qDim_coloring"] = ""
+            df_dimension_list["qDim_coloring"] = None
 
         # Resolve the dictionary structure of attribute "qDim_coloring_baseColor"
         try:
             df_dimension_list_expanded = (
-                df_dimension_list["qDim_coloring_baseColor"].apply(pd.Series).add_prefix("qDim_coloring_baseColor_"))
+                df_dimension_list["qDim_coloring_baseColor"].dropna().apply(pd.Series).add_prefix("qDim_coloring_baseColor_"))
             df_dimension_list = df_dimension_list.drop(columns=["qDim_coloring_baseColor"]).join(
                 df_dimension_list_expanded)
         except KeyError:
-            df_dimension_list["qDim_coloring_baseColor"] = ""
+            df_dimension_list["qDim_coloring_baseColor"] = None
 
         # Resolve the list structure of attribute
         df_dimension_list = df_dimension_list.explode(['qDimInfos', 'qDim_qFieldDefs', 'qDim_qFieldLabels'])
 
         # Resolve the dictionary structure of attribute "qDimInfos"
-        df_dimension_list_expanded = (df_dimension_list["qDimInfos"].apply(pd.Series).add_prefix("qDimInfos_"))
+        df_dimension_list_expanded = (df_dimension_list["qDimInfos"].dropna().apply(pd.Series).add_prefix("qDimInfos_"))
         index = df_dimension_list_expanded.index
         df_dimension_list_expanded = df_dimension_list_expanded[~index.duplicated(keep="first")]
         df_dimension_list = df_dimension_list.drop(columns=["qDimInfos"]).join(df_dimension_list_expanded)
@@ -627,11 +938,11 @@ class QixEngine:
             df_measure_list.loc[len(df_measure_list)] = measure_layout
 
         # Resolve the dictionary structure of attribute "qInfo"
-        df_measure_list_expanded = (df_measure_list["qInfo"].apply(pd.Series).add_prefix("qInfo_"))
+        df_measure_list_expanded = (df_measure_list["qInfo"].dropna().apply(pd.Series).add_prefix("qInfo_"))
         df_measure_list = df_measure_list.drop(columns=["qInfo"]).join(df_measure_list_expanded)
 
         # Resolve the dictionary structure of attribute "qMeasure"
-        df_measure_list_expanded = (df_measure_list["qMeasure"].apply(pd.Series).add_prefix("qMeasure_"))
+        df_measure_list_expanded = (df_measure_list["qMeasure"].dropna().apply(pd.Series).add_prefix("qMeasure_"))
         df_measure_list = df_measure_list.drop(columns=["qMeasure"]).join(df_measure_list_expanded)
 
         # Resolve the dictionary structure of attribute "qMeta"
@@ -640,29 +951,204 @@ class QixEngine:
 
         # Resolve the dictionary structure of attribute "qMeasure_qNumFormat"
         df_measure_list_expanded = (
-            df_measure_list["qMeasure_qNumFormat"].apply(pd.Series).add_prefix("qMeasure_qNumFormat_"))
+            df_measure_list["qMeasure_qNumFormat"].dropna().apply(pd.Series).add_prefix("qMeasure_qNumFormat_"))
         df_measure_list = df_measure_list.drop(columns=["qMeasure_qNumFormat"]).join(df_measure_list_expanded)
 
         # Resolve the dictionary structure of attribute "qMeasure_coloring"
         try:
             df_measure_list_expanded = (
-                df_measure_list["qMeasure_coloring"].apply(pd.Series).add_prefix("qMeasure_coloring_"))
+                df_measure_list["qMeasure_coloring"].dropna().apply(pd.Series).add_prefix("qMeasure_coloring_"))
             df_measure_list = df_measure_list.drop(columns=["qMeasure_coloring"]).join(df_measure_list_expanded)
         except KeyError:
-            df_measure_list["qMeasure_coloring"] = ""
+            df_measure_list["qMeasure_coloring"] = None
 
         # Resolve the dictionary structure of attribute "qMeasure_coloring_baseColor"
         try:
-            df_measure_list_expanded = (df_measure_list["qMeasure_coloring_baseColor"].apply(pd.Series).add_prefix(
+            df_measure_list_expanded = (df_measure_list["qMeasure_coloring_baseColor"].dropna().apply(pd.Series).add_prefix(
                 "qMeasure_coloring_baseColor_"))
             df_measure_list = df_measure_list.drop(columns=["qMeasure_coloring_baseColor"]).join(
                 df_measure_list_expanded)
         except KeyError:
-            df_measure_list["qMeasure_coloring_baseColor"] = ""
+            df_measure_list["qMeasure_coloring_baseColor"] = None
 
         return df_measure_list
 
 
+    def get_app_sheets(self, app_handle):
+        """
+        Retrieves a list with all app sheets and their content containing metadata.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+
+        Returns:
+            DataFrame: A table with all sheets and their content from an app.
+        """
+        # Define the parameters of the session object
+        nx_info = self.structs.nx_info(obj_type="SheetList")
+        sheet_list_def = self.structs.sheet_list_def()
+        gen_obj_props = self.structs.generic_object_properties(info=nx_info, prop_name="qAppObjectListDef",
+                                                               prop_def=sheet_list_def)
+
+        # Create session object
+        session = self.eaa.create_session_object(app_handle, gen_obj_props)
+
+        # Get session handle
+        session_handle = self.get_handle(session)
+
+        # Get session object data
+        session_layout = self.egoa.get_layout(session_handle)
+
+        # Get the sheet list as Dictionary structure
+        sheet_list = session_layout["qAppObjectList"]["qItems"]
+
+        # Define the DataFrame structure
+        df_sheet_list = pd.DataFrame(columns=['qInfo', 'qMeta', 'qSelectionInfo', 'rank', 'thumbnail', 'columns', 'rows', 'cells', 'qChildList', 'gridResolution', 'layoutOptions', 'gridMode', 'customRowBase'])
+
+        for sheet in sheet_list:
+            # Get sheet ID
+            sheet_id = sheet["qInfo"]["qId"]
+            # Get sheet
+            sheet_result = self.eaa.get_object(app_handle=app_handle, object_id=sheet_id)
+            # Get sheet handle
+            sheet_handle = self.get_handle(sheet_result)
+            # Get session object data
+            sheet_layout = self.egoa.get_layout(sheet_handle)
+
+            # Concatenate the measure metadata to the DataFrame structure
+            df_sheet_list.loc[len(df_sheet_list)] = sheet_layout
+
+        # Resolve the dictionary structure of attribute "qInfo"
+        df_sheet_list_expanded = (df_sheet_list["qInfo"].dropna().apply(pd.Series).add_prefix("qInfo_"))
+        df_sheet_list = df_sheet_list.drop(columns=["qInfo"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qMeta"
+        df_sheet_list_expanded = (df_sheet_list["qMeta"].dropna().apply(pd.Series).add_prefix("qMeta_"))
+        df_sheet_list = df_sheet_list.drop(columns=["qMeta"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qSelectionInfo"
+        df_sheet_list["qSelectionInfo"] = df_sheet_list["qSelectionInfo"].apply(
+            lambda x: None if isinstance(x, dict) and len(x) == 0 else x
+        )
+        df_sheet_list_expanded = (df_sheet_list["qSelectionInfo"].dropna().apply(pd.Series).add_prefix("qSelectionInfo_"))
+        df_sheet_list = df_sheet_list.drop(columns=["qSelectionInfo"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "thumbnail"
+        df_sheet_list_expanded = (df_sheet_list["thumbnail"].dropna().apply(pd.Series).add_prefix("thumbnail_"))
+        df_sheet_list = df_sheet_list.drop(columns=["thumbnail"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "thumbnail_qStaticContentUrl"
+        df_sheet_list["thumbnail_qStaticContentUrl"] = df_sheet_list["thumbnail_qStaticContentUrl"].apply(
+            lambda x: None if isinstance(x, dict) and len(x) == 0 else x
+        )
+        df_sheet_list_expanded = (df_sheet_list["thumbnail_qStaticContentUrl"].dropna().apply(pd.Series).add_prefix("thumbnail_qStaticContentUrl_"))
+        df_sheet_list = df_sheet_list.drop(columns=["thumbnail_qStaticContentUrl"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qChildList"
+        df_sheet_list_expanded = (df_sheet_list["qChildList"].dropna().apply(pd.Series).add_prefix("qChildList_"))
+        df_sheet_list = df_sheet_list.drop(columns=["qChildList"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "layoutOptions"
+        df_sheet_list_expanded = (df_sheet_list["layoutOptions"].dropna().apply(pd.Series).add_prefix("layoutOptions_"))
+        df_sheet_list = df_sheet_list.drop(columns=["layoutOptions"]).join(df_sheet_list_expanded)
+
+        # Resolve the list structure of attribute
+        df_sheet_list = df_sheet_list.explode(['cells', 'qChildList_qItems'])
+
+        # Resolve the dictionary structure of attribute "cells"
+        df_sheet_list_expanded = (df_sheet_list["cells"].dropna().apply(pd.Series).add_prefix("cells_"))
+        index = df_sheet_list_expanded.index
+        df_sheet_list_expanded = df_sheet_list_expanded[~index.duplicated(keep="first")]
+        df_sheet_list = df_sheet_list.drop(columns=["cells"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "cells_bounds"
+        df_sheet_list_expanded = (
+            df_sheet_list["cells_bounds"].dropna().apply(pd.Series).add_prefix("cells_bounds_"))
+        index = df_sheet_list_expanded.index
+        df_sheet_list_expanded = df_sheet_list_expanded[~index.duplicated(keep="first")]
+        df_sheet_list = df_sheet_list.drop(columns=["cells_bounds"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qChildList_qItems"
+        df_sheet_list_expanded = (
+            df_sheet_list["qChildList_qItems"].dropna().apply(pd.Series).add_prefix("qChildList_qItems_"))
+        index = df_sheet_list_expanded.index
+        df_sheet_list_expanded = df_sheet_list_expanded[~index.duplicated(keep="first")]
+        df_sheet_list = df_sheet_list.drop(columns=["qChildList_qItems"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qChildList_qItems_qInfo"
+        df_sheet_list_expanded = (
+            df_sheet_list["qChildList_qItems_qInfo"].dropna().apply(pd.Series).add_prefix("qChildList_qItems_qInfo_"))
+        index = df_sheet_list_expanded.index
+        df_sheet_list_expanded = df_sheet_list_expanded[~index.duplicated(keep="first")]
+        df_sheet_list = df_sheet_list.drop(columns=["qChildList_qItems_qInfo"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qChildList_qItems_qMeta"
+        df_sheet_list_expanded = (
+            df_sheet_list["qChildList_qItems_qMeta"].dropna().apply(pd.Series).add_prefix("qChildList_qItems_qMeta_"))
+        index = df_sheet_list_expanded.index
+        df_sheet_list_expanded = df_sheet_list_expanded[~index.duplicated(keep="first")]
+        df_sheet_list = df_sheet_list.drop(columns=["qChildList_qItems_qMeta"]).join(df_sheet_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qChildList_qItems_qData"
+        df_sheet_list_expanded = (
+            df_sheet_list["qChildList_qItems_qData"].dropna().apply(pd.Series).add_prefix("qChildList_qItems_qData_"))
+        index = df_sheet_list_expanded.index
+        df_sheet_list_expanded = df_sheet_list_expanded[~index.duplicated(keep="first")]
+        df_sheet_list = df_sheet_list.drop(columns=["qChildList_qItems_qData"]).join(df_sheet_list_expanded)
+
+        return df_sheet_list
+
+
+    def get_app_variables(self, app_handle):
+        """
+        Retrieves a list with all app variables containing metadata.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+
+        Returns:
+            DataFrame: A table with all variables from an app.
+        """
+        # Define the parameters of the session object
+        nx_info = self.structs.nx_info(obj_type="VariableList")
+        variable_list_def = self.structs.variable_list_def()
+        gen_obj_props = self.structs.generic_object_properties(info=nx_info, prop_name="qVariableListDef",
+                                                               prop_def=variable_list_def)
+
+        # Create session object
+        session = self.eaa.create_session_object(app_handle, gen_obj_props)
+
+        # Get session handle
+        session_handle = self.get_handle(session)
+
+        # Get session object data
+        session_layout = self.egoa.get_layout(session_handle)
+
+        # Get the variable list as Dictionary structure
+        variable_list = session_layout["qVariableList"]["qItems"]
+
+        # Define the DataFrame structure
+        df_variable_list = pd.DataFrame(columns=["qName", "qDefinition", "qMeta", "qInfo", "qData", "qIsScriptCreated", "qIsReserved"])
+
+        for variable in variable_list:
+            # Concatenate the measure metadata to the DataFrame structure
+            df_variable_list.loc[len(df_variable_list)] = variable
+
+        # Resolve the dictionary structure of attribute "qInfo"
+        df_variable_list_expanded = (df_variable_list["qInfo"].dropna().apply(pd.Series).add_prefix("qInfo_"))
+        df_variable_list = df_variable_list.drop(columns=["qInfo"]).join(df_variable_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qMeta"
+        df_variable_list_expanded = (df_variable_list["qMeta"].dropna().apply(pd.Series).add_prefix("qMeta_"))
+        df_variable_list = df_variable_list.drop(columns=["qMeta"]).join(df_variable_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qData"
+        df_variable_list_expanded = (df_variable_list["qData"].dropna().apply(pd.Series).add_prefix("qData_"))
+        df_variable_list = df_variable_list.drop(columns=["qData"]).join(df_variable_list_expanded)
+
+        return df_variable_list
+
+
     def get_app_lineage(self, app_handle):
         """
         Retrieves a list with an app lineage data.