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

qe_api_client/api_classes/engine_app_api.py

@@ -556,16 +556,6 @@ class EngineAppApi:
         except KeyError:
             return response['error']
 
-    # GetDimension: Get the handle of a dimension by using the GetDimension method.  # NOQA
-    # Parameter: dimension id
-    def get_dimension(self, doc_handle, dim_id):
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "GetDimension",
-                          "params": [dim_id]})
-        response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
-        try:
-            return response['result']['qReturn']
-        except KeyError:
-            return response['error']
 
     # GetEmptyScript: Creates a script that contains one section. This section contains Set statements that give  # NOQA
     # localized information from the regional settings of the computer.

qe_api_client/api_classes/engine_generic_dimension_api.py

@@ -18,18 +18,18 @@ class EngineGenericDimensionApi:
         """
         self.engine_socket = socket
 
-    def get_dimension(self, handle, dimension_id):
+    def get_dimension(self, app_handle: int, dimension_id: str):
         """
         Retrieves the definition of a specific dimension from the Qlik Sense engine.
 
         Parameters:
-            handle (int): The handle identifying the dimension object.
+            app_handle (int): The handle identifying the application.
             dimension_id (str): The unique identifier (qId) of the dimension to retrieve.
 
         Returns:
             dict: The definition of the requested dimension (qReturn). In case of an error, returns the error information.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "GetDimension",
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": app_handle, "method": "GetDimension",
                           "params": {"qId": dimension_id}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:

qe_api_client/api_classes/engine_generic_measure_api.py

@@ -18,18 +18,18 @@ class EngineGenericMeasureApi:
         """
         self.engine_socket = socket
 
-    def get_measure(self, handle, measure_id):
+    def get_measure(self, app_handle: int, measure_id: str):
         """
         Retrieves the definition of a specific measure from the Qlik Sense engine.
 
         Parameters:
-            handle (int): The handle identifying the measure object.
+            app_handle (int): The handle identifying the application.
             measure_id (str): The unique identifier (qId) of the measure to retrieve.
 
         Returns:
             dict: The definition of the requested measure (qReturn). In case of an error, returns the error information.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "GetMeasure", "params": {"qId": measure_id}})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": app_handle, "method": "GetMeasure", "params": {"qId": measure_id}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response["result"]["qReturn"]

qe_api_client/engine.py

@@ -9,6 +9,7 @@ import qe_api_client.api_classes.engine_generic_measure_api as engine_generic_me
 import qe_api_client.structs as structs
 import math
 import pandas as pd
+import numpy as np
 
 
 class QixEngine:
@@ -39,42 +40,45 @@ class QixEngine:
         self.structs = structs
         self.app_handle = ''
 
-    def select_in_dimension(self, app_handle, dimension_name, list_of_values):
-        lb_field = self.eaa.get_field(app_handle, dimension_name)
+    def select_in_field(self, app_handle, field_name, list_of_values):
+        lb_field = self.eaa.get_field(app_handle, field_name)
         fld_handle = self.get_handle(lb_field)
-        values_to_select = []
-        for val in list_of_values:
-            fld_value = self.structs.field_value(val)
-            values_to_select.append(fld_value)
-        return self.efa.select_values(fld_handle, values_to_select)
-
-    def select_excluded_in_dimension(self, app_handle, dimension_name):
-        lb_field = self.eaa.get_field(app_handle, dimension_name)
+        if fld_handle is None:
+            return "The field name " + field_name + " doesn't exist!"
+        else:
+            values_to_select = []
+            for val in list_of_values:
+                fld_value = self.structs.field_value(text=val)
+                values_to_select.append(fld_value)
+            return self.efa.select_values(fld_handle, values_to_select)
+
+    def select_excluded_in_field(self, app_handle, field_name):
+        lb_field = self.eaa.get_field(app_handle, field_name)
         fld_handle = self.get_handle(lb_field)
         return self.efa.select_excluded(fld_handle)
 
-    def select_possible_in_dimension(self, app_handle, dimension_name):
-        lb_field = self.eaa.get_field(app_handle, dimension_name)
+    def select_possible_in_field(self, app_handle, field_name):
+        lb_field = self.eaa.get_field(app_handle, field_name)
         fld_handle = self.get_handle(lb_field)
         return self.efa.select_possible(fld_handle)
 
     # return a list of tuples where first value in tuple is the actual
     # data value and the second tuple value is that
     # values selection state
-    def get_list_object_data(self, app_handle, dimension_name):
-        lb_field = self.eaa.get_field(app_handle, dimension_name)
+    def get_list_object_data(self, app_handle, field_name):
+        lb_field = self.eaa.get_field(app_handle, field_name)
         fld_handle = self.get_handle(lb_field)
 
-        nx_inline_dimension_def = self.structs.nx_inline_dimension_def([dimension_name])
-        nx_page = self.structs.nx_page(0, 0, self.efa.get_cardinal(fld_handle))
+        nx_inline_dimension_def = self.structs.nx_inline_dimension_def([field_name])
+        nx_page = self.structs.nx_page(left=0, top=0, width=self.efa.get_cardinal(fld_handle))
         lb_def = self.structs.list_object_def("$", "", nx_inline_dimension_def,
                                               [nx_page])
 
         # Create info structure
-        nx_info = self.structs.nx_info("ListObject", "SLB01")
+        nx_info = self.structs.nx_info(obj_type="ListObject", obj_id="SLB01")
 
         # Create generic object properties structure
-        gen_obj_props = self.structs.generic_object_properties(nx_info, "qListObjectDef", lb_def)
+        gen_obj_props = self.structs.generic_object_properties(info=nx_info, prop_name="qListObjectDef", prop_def=lb_def)
         listobj = self.eaa.create_session_object(app_handle, gen_obj_props)  # NOQA
         listobj_handle = self.get_handle(listobj)
         val_list = self.egoa.get_layout(listobj_handle)["qListObject"]["qDataPages"][0]["qMatrix"]  # NOQA
@@ -89,7 +93,8 @@ class QixEngine:
         fld_handle = self.get_handle(lb_field)
         return self.efa.clear(fld_handle)
 
-    def create_single_master_dimension(self, app_handle, dim_title, dim_def, dim_label):
+    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):
         """
         Creates a single master dimension.
 
@@ -97,18 +102,27 @@ class QixEngine:
             app_handle (int): The handle of the app.
             dim_title (str): The title of the dimension.
             dim_def (str): The definition of the dimension.
-            dim_label (str): The label of the dimension.
+            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.
 
         Returns:
             dict: The handle and Id of the dimension.
         """
-        nx_info = self.structs.nx_info("dimension")
-        lb_dim_def = self.structs.nx_library_dimension_def("N",[dim_def],[""],dim_label)
-        gen_dim_props = self.structs.generic_dimension_properties(nx_info, lb_dim_def, dim_title)
+        if dim_tags is None:
+            dim_tags = []
+        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],
+                                                                         label_expression=dim_label)
+        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)
         master_dim = self.eaa.create_dimension(app_handle, gen_dim_props)
         return master_dim
 
-    def create_master_measure(self, app_handle, mes_title, mes_def, mes_label):
+    def create_master_measure(self, app_handle: int, mes_title: str, mes_def: str, mes_label: str = "",
+                              mes_desc: str = "", mes_tags: list = None):
         """
         Creates a master measure.
 
@@ -116,14 +130,21 @@ class QixEngine:
             app_handle (int): The handle of the app.
             mes_title (str): The title of the measure.
             mes_def (str): The definition of the measure.
-            mes_label (str): The label of the measure.
+            mes_label (str, optional): The label of the measure.
+            mes_desc (str, optional): The description of the measure.
+            mes_tags (list, optional): The tags of the measure.
 
         Returns:
             dict: The handle and Id of the measure.
         """
-        nx_info = self.structs.nx_info("measure")
-        lb_mes_def = self.structs.nx_inline_measure_def(mes_def,mes_label)
-        gen_mes_props = self.structs.generic_measure_properties(nx_info, lb_mes_def, mes_title)
+        if mes_tags is None:
+            mes_tags = []
+        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)
         master_mes = self.eaa.create_measure(app_handle, gen_mes_props)
         return master_mes
 
@@ -213,7 +234,7 @@ class QixEngine:
 
             # Retrieves the hypercube data in a loop (because of limitation from 10.000 cells per call)
             while no_of_rows > page * height:
-                nx_page = self.structs.nx_page(0, page * height, width, height)
+                nx_page = self.structs.nx_page(left=0, top=page * height, width=width, height=height)
                 hc_data = self.egoa.get_hypercube_data(obj_handle, '/qHyperCubeDef', nx_page)[
                     'qDataPages'][0]['qMatrix']
                 data_values.extend(hc_data)
@@ -243,7 +264,7 @@ class QixEngine:
 
             # Gets the column headers for the pivot table
             col_headers = []
-            nx_page_top = self.structs.nx_page(0, 0, width, 1)
+            nx_page_top = self.structs.nx_page(left=0, top=0, width=width, height=1)
             hc_top = self.egoa.get_hypercube_pivot_data(obj_handle, '/qHyperCubeDef', nx_page_top)[
                 'qDataPages'][0]['qTop']
             for top_node in hc_top:
@@ -256,7 +277,7 @@ class QixEngine:
 
             # Retrieves the hypercube data in a loop (bacause of limitation from 10.000 cells per call)
             while no_of_rows > page * height:
-                nx_page = self.structs.nx_page(0, page * height, width, height)
+                nx_page = self.structs.nx_page(left=0, top=page * height, width=width, height=height)
 
                 # Retrieves the row headers for the pivot table
                 hc_left = self.egoa.get_hypercube_pivot_data(obj_handle, '/qHyperCubeDef', nx_page)[
@@ -282,7 +303,7 @@ class QixEngine:
         # if the type of the charts has a stacked data structure
         elif obj_layout['qInfo']['qType'] in ['barchart'] and obj_layout['qHyperCube']['qStackedDataPages'] != []:
             max_no_cells = no_of_columns * no_of_rows
-            nx_page = self.structs.nx_page(0, 0, no_of_columns, no_of_rows)
+            nx_page = self.structs.nx_page(left=0, top=0, width=no_of_columns, height=no_of_rows)
             hc_data = self.egoa.get_hypercube_stack_data(obj_handle, '/qHyperCubeDef', nx_page, max_no_cells)[
                 'qDataPages'][0]['qData'][0]['qSubNodes']
 
@@ -315,32 +336,32 @@ class QixEngine:
             list_of_master_measures (list): A list of master measures.
 
         Returns:
-        DataFrame: A table of the chart content.
+            DataFrame: A table of the chart content.
         """
         # Create dimension property
         hc_dim = []
         for dimension in list_of_dimensions:
-            hc_inline_dim_def = self.structs.nx_inline_dimension_def([dimension])
-            hc_dim.append(self.structs.nx_dimension("", hc_inline_dim_def))
+            hc_inline_dim_def = self.structs.nx_inline_dimension_def(field_definitions=[dimension])
+            hc_dim.append(self.structs.nx_dimension(library_id="", dim_def=hc_inline_dim_def))
         for dimension in list_of_master_dimensions:
-            hc_dim.append(self.structs.nx_dimension(dimension))
+            hc_dim.append(self.structs.nx_dimension(library_id=dimension))
 
         # Create measure property
         hc_mes = []
         for measure in list_of_measures:
-            hc_inline_mes = self.structs.nx_inline_measure_def(measure)
-            hc_mes.append(self.structs.nx_measure("", hc_inline_mes))
+            hc_inline_mes = self.structs.nx_inline_measure_def(definition=measure)
+            hc_mes.append(self.structs.nx_measure(library_id="", mes_def=hc_inline_mes))
         for measure in list_of_master_measures:
-            hc_mes.append(self.structs.nx_measure(measure))
+            hc_mes.append(self.structs.nx_measure(library_id=measure))
 
         # Create hypercube structure
-        hc_def = self.structs.hypercube_def("$", hc_dim, hc_mes)
+        hc_def = self.structs.hypercube_def(state_name="$", nx_dims=hc_dim, nx_meas=hc_mes)
 
         # Create info structure
-        nx_info = self.structs.nx_info("table")
+        nx_info = self.structs.nx_info(obj_type="table")
 
         # Create generic object properties structure
-        gen_obj_props = self.structs.generic_object_properties(nx_info, "qHyperCubeDef", hc_def)
+        gen_obj_props = self.structs.generic_object_properties(info=nx_info, prop_name="qHyperCubeDef", prop_def=hc_def)
 
         # Create session object
         hc_obj = self.eaa.create_session_object(app_handle, gen_obj_props)
@@ -368,7 +389,7 @@ class QixEngine:
 
         # Retrieves the hypercube data in a loop (because of limitation from 10.000 cells per call)
         while no_of_rows > page * height:
-            nx_page = self.structs.nx_page(0, page * height, width, height)
+            nx_page = self.structs.nx_page(left=0, top=page * height, width=width, height=height)
             hc_data = self.egoa.get_hypercube_data(hc_obj_handle, '/qHyperCubeDef', nx_page)['qDataPages'][0]['qMatrix']
             data_values.extend(hc_data)
             page += 1
@@ -380,4 +401,286 @@ class QixEngine:
         df.columns = column_names
 
         # Returns the Dataframe
-        return df
+        return df
+
+    def get_apps(self):
+        """
+        Retrieves a list with all apps on the server containing metadata.
+
+        Parameters:
+
+        Returns:
+            DataFrame: A table with all server apps.
+        """
+
+        # Get all apps from Qlik Server
+        doc_list = self.ega.get_doc_list()
+
+        # Convert into DataFrame structure
+        df_doc_list = pd.DataFrame(doc_list)
+
+        # Resolve the attribute "qMeta"
+        field_meta = df_doc_list['qMeta'].apply(pd.Series).reindex(columns=["createdDate", "modifiedDate", "published",
+                                                                            "publishTime", "privileges", "description",
+                                                                            "qStaticByteSize", "dynamicColor", "create",
+                                                                            "stream", "canCreateDataConnections"])
+
+        # Concat the resolved attribute and rename the new columns
+        df_doc_list_meta = pd.concat([df_doc_list.drop(['qMeta'], axis=1), field_meta], axis=1)
+        df_doc_list_meta = df_doc_list_meta.rename(columns={"createdDate": "qMeta_createdDate",
+                                                            "modifiedDate": "qMeta_modifiedDate",
+                                                            "published": "qMeta_published",
+                                                            "publishTime": "qMeta_publishTime",
+                                                            "privileges": "qMeta_privileges",
+                                                            "description": "qMeta_description",
+                                                            "qStaticByteSize": "qMeta_qStaticByteSize",
+                                                            "dynamicColor": "qMeta_dynamicColor",
+                                                            "create": "qMeta_create",
+                                                            "stream": "qMeta_stream",
+                                                            "canCreateDataConnections": "qMeta_canCreateDataConnections"})
+
+        # Resolve the attribute "stream"
+        field_meta_stream = df_doc_list_meta['qMeta_stream'].apply(pd.Series).reindex(columns=["id", "name"])
+
+        # Concat the resolved attribute and rename the new columns
+        df_doc_list_meta_stream = pd.concat([df_doc_list_meta.drop(['qMeta_stream'], axis=1), field_meta_stream],
+                                            axis=1)
+        df_doc_list_meta_stream = df_doc_list_meta_stream.rename(
+            columns={"id": "qMeta_stream_id", "name": "qMeta_stream_name"})
+
+        # Resolve the attribute "qThumbnail"
+        field_thumbnail = df_doc_list_meta_stream['qThumbnail'].apply(pd.Series).reindex(columns=["qUrl"])
+
+        ## Concat the resolved attribute and rename the new columns
+        df_doc_list_resolved = pd.concat([df_doc_list_meta_stream.drop(['qThumbnail'], axis=1), field_thumbnail],
+                                         axis=1)
+        df_doc_list_resolved = df_doc_list_resolved.rename(columns={"qUrl": "qThumbnail_qUrl"}).replace(np.nan,'')
+
+        return df_doc_list_resolved
+
+
+    def get_app_fields(self, app_handle):
+        """
+        Retrieves a list with all app fields containing meta data.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+
+        Returns:
+            DataFrame: A table with all fields from an app.
+        """
+        # Define the parameters of the session object
+        nx_info = self.structs.nx_info(obj_type="FieldList")
+        field_list_def = self.structs.field_list_def()
+        gen_obj_props = self.structs.generic_object_properties(info=nx_info, prop_name="qFieldListDef",
+                                                               prop_def=field_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
+        layout = self.egoa.get_layout(session_handle)
+
+        # Get the field list as Dictionary structure
+        fields_list = layout["qFieldList"]["qItems"]
+
+        # Define the DataFrame structure
+        df_fields_list = pd.DataFrame(columns=['qIsHidden', 'qIsSystem', 'qName', 'qCardinal', 'qTags', 'qSrcTables'])
+
+        for fields in fields_list:
+            # Concatenate the field list on the DataFrame structure
+            df_fields_list.loc[len(df_fields_list)] = fields
+
+        return df_fields_list
+
+
+    def get_app_dimensions(self, app_handle):
+        """
+        Retrieves a list with all app dimensions containing metadata.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+
+        Returns:
+            DataFrame: A table with all dimensions from an app.
+        """
+        # Define the parameters of the session object
+        nx_info = self.structs.nx_info(obj_type="DimensionList")
+        dimension_list_def = self.structs.dimension_list_def()
+        gen_obj_props = self.structs.generic_object_properties(info=nx_info, prop_name="qDimensionListDef",
+                                                               prop_def=dimension_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 dimension list as Dictionary structure
+        dimension_list = session_layout["qDimensionList"]["qItems"]
+
+        # Define the DataFrame structure
+        df_dimension_list = pd.DataFrame(columns=["qInfo", "qMeta", "qDim", "qDimInfos"])
+
+        for dimension in dimension_list:
+            # Get dimension ID
+            dim_id = dimension["qInfo"]["qId"]
+            # Get dimension
+            dim_result = self.egda.get_dimension(app_handle=app_handle, dimension_id=dim_id)
+            # Get dimension handle
+            dim_handle = self.get_handle(dim_result)
+            # Get dimension metadata
+            dim_layout = self.egoa.get_layout(dim_handle)
+
+            # Concatenate the dimension to the DataFrame structure
+            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 = 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 = 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 = 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 = df_dimension_list.drop(columns=["qDim_coloring"]).join(df_dimension_list_expanded)
+        except KeyError:
+            df_dimension_list["qDim_coloring"] = ""
+
+        # 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 = df_dimension_list.drop(columns=["qDim_coloring_baseColor"]).join(
+                df_dimension_list_expanded)
+        except KeyError:
+            df_dimension_list["qDim_coloring_baseColor"] = ""
+
+        # 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_"))
+        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)
+
+        return df_dimension_list
+
+
+    def get_app_measures(self, app_handle):
+        """
+        Retrieves a list with all app measures containing metadata.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+
+        Returns:
+            DataFrame: A table with all measures from an app.
+        """
+        # Define the parameters of the session object
+        nx_info = self.structs.nx_info(obj_type="MeasureList")
+        measure_list_def = self.structs.measure_list_def()
+        gen_obj_props = self.structs.generic_object_properties(info=nx_info, prop_name="qMeasureListDef",
+                                                               prop_def=measure_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 measure list as Dictionary structure
+        measure_list = session_layout["qMeasureList"]["qItems"]
+
+        # Define the DataFrame structure
+        df_measure_list = pd.DataFrame(columns=["qInfo", "qMeasure", "qMeta"])
+
+        for measure in measure_list:
+            # Get measure ID
+            measure_id = measure["qInfo"]["qId"]
+            # Get measure
+            measure_result = self.egma.get_measure(app_handle=app_handle, measure_id=measure_id)
+            # Get measure handle
+            measure_handle = self.get_handle(measure_result)
+            # Get session object data
+            measure_layout = self.egoa.get_layout(measure_handle)
+
+            # Concatenate the measure metadata to the DataFrame structure
+            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 = 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 = df_measure_list.drop(columns=["qMeasure"]).join(df_measure_list_expanded)
+
+        # Resolve the dictionary structure of attribute "qMeta"
+        df_measure_list_expanded = (df_measure_list["qMeta"].apply(pd.Series).add_prefix("qMeta_"))
+        df_measure_list = df_measure_list.drop(columns=["qMeta"]).join(df_measure_list_expanded)
+
+        # 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 = 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 = df_measure_list.drop(columns=["qMeasure_coloring"]).join(df_measure_list_expanded)
+        except KeyError:
+            df_measure_list["qMeasure_coloring"] = ""
+
+        # 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(
+                "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"] = ""
+
+        return df_measure_list
+
+
+    def get_app_lineage(self, app_handle):
+        """
+        Retrieves a list with an app lineage data.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+
+        Returns:
+            DataFrame: A table with lineage data from an app.
+        """
+        # Get lineage data from an app
+        lineage_list = self.eaa.get_lineage(app_handle)
+
+        # Define the DataFrame structure
+        df_lineage_list = pd.DataFrame(columns=['qDiscriminator', 'qStatement'])
+
+        for lineage in lineage_list:
+            # Concatenate the lineage row on the DataFrame structure
+            df_lineage_list.loc[len(df_lineage_list)] = lineage
+
+        return df_lineage_list

qe_api_client/structs.py

@@ -2,6 +2,7 @@ def list_object_def(state_name="$", library_id="", field_defs=[], initial_data_f
     return {"qStateName": state_name, "qLibraryId": library_id, "qDef": field_defs,
             "qInitialDataFetch": initial_data_fetch}
 
+
 def hypercube_def(state_name="$", nx_dims=[], nx_meas=[], nx_page=[], inter_column_sort=[0, 1, 2], suppress_zero=False,
                   suppress_missing=False):
     return {"qStateName": state_name, "qDimensions": nx_dims, "qMeasures": nx_meas,
@@ -10,23 +11,27 @@ def hypercube_def(state_name="$", nx_dims=[], nx_meas=[], nx_page=[], inter_colu
             "qAlwaysFullyExpanded": False, "qMaxStackedCells": 5000, "qPopulateMissing": False,
             "qShowTotalsAbove": False, "qIndentMode": False, "qCalcCond": "", "qSortbyYValue": 0}
 
+
 def nx_inline_dimension_def(field_definitions=[], field_labels=[], sort_criterias=[], grouping='N'):
     return {"qGrouping": grouping, "qFieldDefs": field_definitions, "qFieldLabels": field_labels,
             "qSortCriterias": sort_criterias, "qReverseSort": False}
 
+
 def nx_inline_measure_def(definition, label="", description="", tags=[], grouping="N"):
     return {"qLabel": label, "qDescription": description, "qTags": tags, "qGrouping": grouping, "qDef":	definition}
 
+
 def nx_page(left=0, top=0, width=2, height=2):
     return {"qLeft": left, "qTop": top, "qWidth": width, "qHeight": height}
 
+
 def nx_info(obj_type, obj_id=""):
     """
     Retrieves the data from a specific list object in a generic object.
 
     Parameters:
         obj_type (str): Type of the object. This parameter is mandatory.
-        obj_id (str): Identifier of the object. If the chosen identifier is already in use, the engine automatically
+        obj_id (str, optional): Identifier of the object. If the chosen identifier is already in use, the engine automatically
         sets another one. If an identifier is not set, the engine automatically sets one. This parameter is optional.
 
     Returns:
@@ -34,45 +39,84 @@ def nx_info(obj_type, obj_id=""):
     """
     return {"qId": obj_id, "qType": obj_type}
 
+
 def nx_dimension(library_id="", dim_def={}, null_suppression=False):
     return {"qLibraryId": library_id, "qDef": dim_def, "qNullSuppression": null_suppression}
 
+
 def nx_measure(library_id="", mes_def={}, sort_by={}):
     return {"qLibraryId": library_id, "qDef": mes_def, "qSortBy": sort_by}
 
+
 def generic_object_properties(info, prop_name, prop_def, extends_id="", state_name="$"):
     return {"qInfo": info, "qExtendsId": extends_id, prop_name: prop_def, "qStateName": state_name}
 
+
 def sort_criteria(state=0, freq=0, numeric=0, ascii=0, load_order=1):
     return {"qSortByState": state, "qSortByFrequency": freq, "qSortByNumeric": numeric, "qSortByAscii": ascii,
             "qSortByLoadOrder": load_order, "qSortByExpression": 0, "qExpression": {"qv": ""}}
 
+
 def field_value(text, is_numeric = False, number = 0):
     return {"qText": text, "qIsNumeric": is_numeric, "qNumber": number}
 
-def generic_dimension_properties(info, lb_dim_def, dim_title):
-    return {"qInfo": info, "qDim": lb_dim_def, "qMetaDef": {"title": dim_title}}
 
-def nx_library_dimension_def(grouping="N", field_definitions=[], field_labels=[""], label_expression=""):
+def generic_dimension_properties(nx_info: dict, nx_library_dimension_def: dict, title: str, description: str = "",
+                                 tags: list = None):
+    if tags is None:
+        tags = []
+    return {"qInfo": nx_info, "qDim": nx_library_dimension_def, "qMetaDef": {"title": title, "description": description,
+                                                                             "tags": tags}}
+
+
+def nx_library_dimension_def(grouping: str = "N", field_definitions: list = None, field_labels: list = None,
+                             label_expression: str = ""):
+    if field_labels is None:
+        field_labels = []
+    if field_definitions is None:
+        field_definitions = []
     return {"qGrouping": grouping, "qFieldDefs": field_definitions, "qFieldLabels": field_labels,
             "qLabelExpression": label_expression}
 
-def nx_library_measure_def(label, mes_def, grouping="N", expressions=[], active_expression=0, label_expression="",
-                           num_format={}):
+
+def nx_library_measure_def(label: str, mes_def: str, grouping: str = "N", expressions: list = None,
+                           active_expression: int = 0, label_expression:str = "", num_format: dict = None):
+    if num_format is None:
+        num_format = {}
+    if expressions is None:
+        expressions = []
     return {"qLabel": label, "qDef": mes_def,"qGrouping": grouping, "qExpressions": expressions,
             "qActiveExpression": active_expression, "qLabelExpression": label_expression, "qNumFormat": num_format}
 
-def num_format(type="U", n_dec=10, use_thou=0, fmt="", dec="", thou=""):
+
+def num_format(type: str = "U", n_dec: int = 10, use_thou:int = 0, fmt: str = "", dec: str = "", thou: str = ""):
     return {"qType": type, "qnDec": n_dec, "qUseThou": use_thou, "qFmt": fmt, "qDec": dec, "qThou": thou}
 
-def generic_measure_properties(info, lb_meas_def, meas_title):
-    return {"qInfo": info, "qMeasure": lb_meas_def, "qMetaDef": {"title": meas_title}}
+
+def generic_measure_properties(nx_info: dict, nx_library_measure_def: dict, title: str, description: str = "",
+                               tags: list = None):
+    if tags is None:
+        tags = []
+    return {"qInfo": nx_info, "qMeasure": nx_library_measure_def, "qMetaDef": {"title": title,
+                                                                               "description": description,
+                                                                               "tags": tags}}
+
 
 def do_reload_ex_params(mode=0, partial=False, debug=False, reload_id="", skip_store=False, row_limit=0):
     return {"qMode": mode, "qPartial": partial, "qDebug": debug, "qReloadId": reload_id, "qSkipStore": skip_store,
             "qRowLimit": row_limit}
 
+
 def dimension_list_def():
-    return {"qInfo": {"qType": "DimensionList"},
-            "qDimensionListDef": {"qType": "dimension",
-            "qData": {"title": "/title", "tags": "/tags", "grouping": "/qDim/qGrouping", "info": "/qDimInfos"}}}
+    return {"qType": "dimension",
+            "qData": {"title": "/title", "tags": "/tags", "grouping": "/qDim/qGrouping", "info": "/qDimInfos"}}
+
+
+def measure_list_def():
+    return {"qType": "measure", "qData": {"title": "/title", "tags": "/tags"}}
+
+
+def field_list_def(show_system: bool = True, show_hidden: bool = True, show_derived_fields: bool = True,
+                   show_semantic: bool = True, show_src_tables: bool = True, show_implicit: bool = True):
+    return {"qShowSystem": show_system, "qShowHidden": show_hidden,	"qShowDerivedFields": show_derived_fields,
+            "qShowSemantic": show_semantic, "qShowSrcTables": show_src_tables, "qShowImplicit": show_implicit}

{qe_api_client-2.4.0.dist-info → qe_api_client-2.5.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.2
 Name: qe-api-client
-Version: 2.4.0
-Summary: Python wrapper around Qlik Engine JSON API
+Version: 2.5.0
+Summary: Python client for the Qlik Engine JSON API
 Home-page: https://github.com/lr-bicc/qe-api-client
 Author: Rumen Vasilev
 Author-email: R.Vasilev@LRWorld.com

{qe_api_client-2.4.0.dist-info → qe_api_client-2.5.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
 qe_api_client/__init__.py,sha256=bypB4CIjpHtf5Pu_NwtJajC69zqQD7qB9jo8cCX0B54,23
-qe_api_client/engine.py,sha256=SCTjKlhtir2kOMNDnfwd1Cz-Su6xxDk79GBUtAMgSpU,16900
+qe_api_client/engine.py,sha256=AGv3Ab5YE5-PpNdkQF6aCLYECKkgbiU96jqEcpb6VUE,32019
 qe_api_client/engine_communicator.py,sha256=q6x7ix2Ev8yGmTTm7cf1vHcidOihKM0HjDXeJ-dZYjk,1133
-qe_api_client/structs.py,sha256=eZw-M9QBhZe_lHxjMcWU5TJVi18G43FhCMMGzjdJxAk,4502
+qe_api_client/structs.py,sha256=9_2LzC8Er_cFNmGPLRB_xuQ0v3AHY24XirGFVSBxkMo,5996
 qe_api_client/api_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qe_api_client/api_classes/engine_app_api.py,sha256=H0CF-BwSUi1ZpZo7pyQg736jsdKm5biShVcELun9jwY,38021
+qe_api_client/api_classes/engine_app_api.py,sha256=_wNFr3scbw0THoM_mMpSapKyiNEhjB4qYBDNgZLLoHg,37493
 qe_api_client/api_classes/engine_field_api.py,sha256=zCLIR7rmxqwIrJYK_-uHVEhMvBcEP2qofuX8ZPygqCA,5479
-qe_api_client/api_classes/engine_generic_dimension_api.py,sha256=1joTET6GWCTW-80wafrajLQuMyFwIPp0QKoILyLdP1U,1377
-qe_api_client/api_classes/engine_generic_measure_api.py,sha256=zbRYRA99LQS9SY3QVgoUABqgVDRPwBQ8o2ZbESVEsHE,1321
+qe_api_client/api_classes/engine_generic_dimension_api.py,sha256=OdYnL54jTaNgfICDj5czJcFB1QZ4Y0s_YslqomQY26I,1394
+qe_api_client/api_classes/engine_generic_measure_api.py,sha256=uj4i_ykX9F9Dtk78fOidMBhzSP8vEucEfrB6MrLwgPI,1340
 qe_api_client/api_classes/engine_generic_object_api.py,sha256=nqsEtvKkt5XkUEIVUoBtNVXtmUvuifxrgTcw2fDuaOE,8218
 qe_api_client/api_classes/engine_generic_variable_api.py,sha256=sWXZpE-GLfcMijmfORnDNrJ6lmXX3x5TRHlkEu_i0BQ,2027
 qe_api_client/api_classes/engine_global_api.py,sha256=G6QQHI36WOo7W25zg4Uz__gMSLC2ptNTvbBdElPzgZI,27535
-qe_api_client-2.4.0.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-qe_api_client-2.4.0.dist-info/METADATA,sha256=uXwa8Jwcq9-w4r0o0CbET_lwWPM87WLY1PwxUkJYBNo,2363
-qe_api_client-2.4.0.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-qe_api_client-2.4.0.dist-info/top_level.txt,sha256=m_43YagP8UtZgJHmZEfu0vlBNwt36M01-Qby2jByMnk,14
-qe_api_client-2.4.0.dist-info/RECORD,,
+qe_api_client-2.5.0.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+qe_api_client-2.5.0.dist-info/METADATA,sha256=TcvlAA9v6e69nWGG-dCXD9E0lxx_jrxrjBi7cVLKgmw,2363
+qe_api_client-2.5.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+qe_api_client-2.5.0.dist-info/top_level.txt,sha256=m_43YagP8UtZgJHmZEfu0vlBNwt36M01-Qby2jByMnk,14
+qe_api_client-2.5.0.dist-info/RECORD,,

{qe_api_client-2.4.0.dist-info → qe_api_client-2.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.1)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any