qe-api-client 2.5.0__tar.gz → 2.6.0__tar.gz

{qe_api_client-2.5.0 → qe_api_client-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qe-api-client
-Version: 2.5.0
+Version: 2.6.0
 Summary: Python client for the Qlik Engine JSON API
 Home-page: https://github.com/lr-bicc/qe-api-client
 Author: Rumen Vasilev
@@ -19,13 +19,14 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
 # Qlik Engine API Client
 
-Python wrapper around [Qlik Engine JSON API](https://help.qlik.com/en-US/sense-developer/February2024/Subsystems/EngineAPI/Content/Sense_EngineAPI/introducing-engine-API.htm)
+Python client for the [Qlik Engine JSON API](https://help.qlik.com/en-US/sense-developer/November2024/Subsystems/EngineAPI/Content/Sense_EngineAPI/introducing-engine-API.htm)
 
 Forked from [jhettler/pyqlikengine](https://github.com/jhettler/pyqlikengine)
 

{qe_api_client-2.5.0 → qe_api_client-2.6.0}/README.md

@@ -1,6 +1,6 @@
 # Qlik Engine API Client
 
-Python wrapper around [Qlik Engine JSON API](https://help.qlik.com/en-US/sense-developer/February2024/Subsystems/EngineAPI/Content/Sense_EngineAPI/introducing-engine-API.htm)
+Python client for the [Qlik Engine JSON API](https://help.qlik.com/en-US/sense-developer/November2024/Subsystems/EngineAPI/Content/Sense_EngineAPI/introducing-engine-API.htm)
 
 Forked from [jhettler/pyqlikengine](https://github.com/jhettler/pyqlikengine)
 

{qe_api_client-2.5.0 → qe_api_client-2.6.0}/qe_api_client/api_classes/engine_app_api.py

@@ -115,18 +115,18 @@ class EngineAppApi:
         except KeyError:
             return response['error']
 
-    def get_object(self, doc_handle, object_id):
+    def get_object(self, app_handle, object_id):
         """
         Retrieves a specific object from the app identified by the document handle.
 
         Parameters:
-            doc_handle (int): The handle identifying the app document.
+            app_handle (int): The handle identifying the app document.
             object_id (str): The ID of the object to retrieve.
 
         Returns:
             dict: The retrieved object (qReturn). In case of an error, returns the error information.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "GetObject",
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": app_handle, "method": "GetObject",
                           "params": {"qId": object_id}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:

{qe_api_client-2.5.0 → qe_api_client-2.6.0}/qe_api_client/api_classes/engine_generic_object_api.py

@@ -24,24 +24,54 @@ class EngineGenericObjectApi:
             socket (object): The socket connection to the Qlik Sense engine.
         """
         self.engine_socket = socket
-    def create_child(self, handle, params):
+
+    def apply_patches(self, handle: int, patches: list, soft_patch: bool = False):
         """
-        Retrieves the layout structure of a specific generic object.
+        Applies a patch to the properties of an object. Allows an update to some of the properties. It is possible to
+        apply a patch to the properties of a generic object, that is not persistent. Such a patch is called a soft patch.
+        In that case, the result of the operation on the properties (add, remove or delete) is not shown when doing
+        GetProperties, and only a GetLayout call shows the result of the operation. Properties that are not persistent
+        are called soft properties. Once the engine session is over, soft properties are cleared. It should not be
+        possible to patch "/qInfo/qId", and it will be forbidden in the near future.
 
         Parameters:
             handle (int): The handle identifying the generic object.
-            params (str): The parameters of the generic object.
+            patches (list): List of patches.
+            soft_patch (bool, optional): If set to true, it means that the properties to be applied are not persistent.
+            The patch is a soft patch. The default value is false.
 
         Returns:
-            dict: The layout structure of the generic object (qLayout). In case of an error, returns the error information.
+            dict: Operation succeeded.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "CreateChild", "params": [params]})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "ApplyPatches",
+                          "params": {"qPatches": patches, "qSoftPatch": soft_patch}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response["result"]
         except KeyError:
             return response["error"]
 
+    def create_child(self, handle: int, prop: dict, prop_for_this: dict = None):
+        """
+        Creates a generic object that is a child of another generic object.
+
+        Parameters:
+            handle (int): The handle identifying the generic object.
+            prop (dict): Information about the child. It is possible to create a child that is linked to another object.
+            prop_for_this (dict, optional): Identifier of the parent's object. Should be set to update the properties of
+            the parent's object at the same time the child is created.
+
+        Returns:
+            dict: The layout structure of the generic object (qLayout). In case of an error, returns the error information.
+        """
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "CreateChild",
+                          "params": {"qProp": prop, "qPropForThis": prop_for_this}})
+        response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
+        try:
+            return response["result"]["qReturn"]
+        except KeyError:
+            return response["error"]
+
     def get_layout(self, handle):
         """
         Retrieves the layout structure of a specific generic object.

{qe_api_client-2.5.0 → qe_api_client-2.6.0}/qe_api_client/engine.py

@@ -111,6 +111,8 @@ class QixEngine:
         """
         if dim_tags is None:
             dim_tags = []
+
+        # Define of the single dimension properties
         nx_info = self.structs.nx_info(obj_type="dimension")
         nx_library_dimension_def = self.structs.nx_library_dimension_def(grouping="N", field_definitions=[dim_def],
                                                                          field_labels=[dim_title],
@@ -118,6 +120,8 @@ class QixEngine:
         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)
         return master_dim
 
@@ -139,15 +143,211 @@ 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 == "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 +390,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 +575,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 +762,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 +847,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 +860,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.