qe-api-client 1.2.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

qe_api_client/engine.py

@@ -1,12 +1,14 @@
-import qe_api_client.engine_app_api as engine_app_api
+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.engine_field_api as engine_field_api
-import qe_api_client.engine_generic_object_api as engine_generic_object_api
-import qe_api_client.engine_global_api as engine_global_api
-import qe_api_client.engine_generic_variable_api as engine_generic_variable_api
-import qe_api_client.engine_generic_dimension_api as engine_generic_dimension_api
-import qe_api_client.engine_generic_measure_api as engine_generic_measure_api
+import qe_api_client.api_classes.engine_field_api as engine_field_api
+import qe_api_client.api_classes.engine_generic_object_api as engine_generic_object_api
+import qe_api_client.api_classes.engine_global_api as engine_global_api
+import qe_api_client.api_classes.engine_generic_variable_api as engine_generic_variable_api
+import qe_api_client.api_classes.engine_generic_dimension_api as engine_generic_dimension_api
+import qe_api_client.api_classes.engine_generic_measure_api as engine_generic_measure_api
 import qe_api_client.structs as structs
+import math
+import pandas as pd
 
 
 class QixEngine:
@@ -28,7 +30,7 @@ class QixEngine:
         self.egva = engine_generic_variable_api.EngineGenericVariableApi(self.conn)
         self.egda = engine_generic_dimension_api.EngineGenericDimensionApi(self.conn)
         self.egma = engine_generic_measure_api.EngineGenericMeasureApi(self.conn)
-        self.Structs = structs.Structs()
+        self.structs = structs
         self.app_handle = ''
 
     def create_app(self, app_name='my_app'):
@@ -47,57 +49,9 @@ class QixEngine:
         self.app_handle = self.ega.get_handle(opened_app)
         return opened_app['qGenericId']
 
-    def create_hypercube(self, list_of_dimensions=[],
-                         list_of_measures=[], rows_to_return=1000):
-        no_of_columns = len(list_of_dimensions) + len(list_of_measures)
-        hc_dim = []
-        for d in list_of_dimensions:
-            hc_inline_dim = self.Structs.nx_inline_dimension_def([d])
-            hc_dim.append(self.Structs.nx_hypercube_dimensions(hc_inline_dim))
-        hc_mes = []
-        for m in list_of_measures:
-            hc_mes_sort = self.Structs.nx_sort_by()
-            hc_inline_mes = self.Structs.nx_inline_measure_def(m)
-            hc_mes.append(self.Structs.nx_hypercube_measure(hc_mes_sort,
-                                                            hc_inline_mes))
-        nx_page = self.Structs.nx_page(0, 0, rows_to_return, no_of_columns)
-        hc_def = self.Structs.hypercube_def("$", hc_dim, hc_mes, [nx_page])
-        hc_response = self.eaa.create_object(self.app_handle, "CH01",
-                                             "Chart", "qHyperCubeDef", hc_def)
-        hc_handle = self.ega.get_handle(hc_response["qReturn"])
-        self.egoa.get_layout(hc_handle)
-        hc_data = self.egoa.get_hypercube_data(hc_handle, "/qHyperCubeDef",
-                                               [nx_page])
-        no_of_columns = len(list_of_dimensions)+len(list_of_measures)
-        return hc_data, no_of_columns
-
-    @staticmethod
-    def convert_hypercube_to_matrix(hc_data, no_of_columns):
-        rows = hc_data["qDataPages"][0]['qMatrix']
-        matrix = [[0 for x in range(no_of_columns)] for y in range(len(rows))]
-        for col_idx, row in enumerate(rows):
-            for cell_idx, cell_val in enumerate(row):
-                matrix[col_idx][cell_idx] = cell_val['qText']
-        return [list(i) for i in zip(*matrix)]
-
-    @staticmethod
-    def convert_hypercube_to_inline_table(hc_data, table_name):
-        rows = hc_data["qDataPages"][0]['qMatrix']
-        script = str.format('{0}:{1}Load * Inline [{1}', table_name, '\n')
-        inline_rows = ''
-        header_row = ''
-        for col_idx in range(len(rows[0])):
-            header_row = header_row + str.format('Column{0}{1}', col_idx, ',')
-        header_row = header_row[:-1] + '\n'
-        for row in rows:
-            for cell_val in row:
-                inline_rows = inline_rows + "'" + cell_val['qText'] + "'" + ','
-            inline_rows = inline_rows[:-1] + '\n'
-        return script + header_row + inline_rows + '];'
-
     def select_in_dimension(self, dimension_name, list_of_values):
         lb_field = self.eaa.get_field(self.app_handle, dimension_name)
-        fld_handle = self.ega.get_handle(lb_field["qReturn"])
+        fld_handle = self.ega.get_handle(lb_field)
         values_to_select = []
         for val in list_of_values:
             val = {'qText': val}
@@ -106,12 +60,12 @@ class QixEngine:
 
     def select_excluded_in_dimension(self, dimension_name):
         lb_field = self.eaa.get_field(self.app_handle, dimension_name)
-        fld_handle = self.ega.get_handle(lb_field["qReturn"])
+        fld_handle = self.ega.get_handle(lb_field)
         return self.efa.select_excluded(fld_handle)
 
     def select_possible_in_dimension(self, dimension_name):
         lb_field = self.eaa.get_field(self.app_handle, dimension_name)
-        fld_handle = self.ega.get_handle(lb_field["qReturn"])
+        fld_handle = self.ega.get_handle(lb_field)
         return self.efa.select_possible(fld_handle)
 
     # return a list of tuples where first value in tuple is the actual
@@ -119,18 +73,12 @@ class QixEngine:
     # values selection state
     def get_list_object_data(self, dimension_name):
         lb_field = self.eaa.get_field(self.app_handle, dimension_name)
-        fld_handle = self.ega.get_handle(lb_field["qReturn"])
-        nx_page = self.Structs.nx_page(0, 0,
-                                       self.efa.get_cardinal(
-                                           fld_handle)["qReturn"]
-                                       )
-        lb_def = self.Structs.list_object_def("$", "",
-                                              [dimension_name],
-                                              None, None, [nx_page]
-                                              )
-        lb_param = {"qInfo": {"qId": "SLB01", "qType": "ListObject"},
-                    "qListObjectDef": lb_def}
-        listobj_handle = self.eaa.create_session_object(self.app_handle, lb_param)["qReturn"]["qHandle"]  # NOQA
+        fld_handle = self.ega.get_handle(lb_field)
+        nx_page = self.structs.nx_page(0, 0, self.efa.get_cardinal(fld_handle)["qReturn"])
+        lb_def = self.structs.list_object_def("$", "",[dimension_name], None,
+                                              None, [nx_page])
+        lb_param = {"qInfo": {"qId": "SLB01", "qType": "ListObject"}, "qListObjectDef": lb_def}
+        listobj_handle = self.eaa.create_session_object(self.app_handle, lb_param)["qHandle"]  # NOQA
         val_list = self.egoa.get_layout(listobj_handle)["qListObject"]["qDataPages"][0]["qMatrix"]  # NOQA
         val_n_state_list = []
         for val in val_list:
@@ -139,7 +87,7 @@ class QixEngine:
 
     def clear_selection_in_dimension(self, dimension_name):
         lb_field = self.eaa.get_field(self.app_handle, dimension_name)
-        fld_handle = self.ega.get_handle(lb_field["qReturn"])
+        fld_handle = self.ega.get_handle(lb_field)
         return self.efa.clear(fld_handle)['qReturn']
 
     def clear_all_selections(self):
@@ -150,3 +98,236 @@ class QixEngine:
 
     def disconnect(self):
         self.conn.close_qvengine_connection(self.conn)
+
+    @staticmethod
+    def get_handle(obj):
+        """
+        Retrieves the handle 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["qHandle"]
+        except ValueError:
+            return "Bad handle value in " + obj
+
+    def get_chart_data(self, app_handle, obj_id):
+        """
+        Retrieves the data from a given chart object.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+            obj_id (str): The ID of the chart object.
+
+        Returns:
+        DataFrame: A table of the chart content.
+        """
+        # Get object ID
+        obj = self.eaa.get_object(app_handle, obj_id)
+        if obj['qType'] is None:
+            return 'Chart ID does not exists!'
+
+
+        # Get object handle
+        obj_handle = self.get_handle(obj)
+        # Get object layout
+        obj_layout = self.egoa.get_layout(obj_handle)
+
+        # Determine the number of the columns and the rows the table has and splits in certain circumstances the table
+        # calls
+        no_of_columns = obj_layout['qHyperCube']['qSize']['qcx']
+        width = no_of_columns
+        no_of_rows = obj_layout['qHyperCube']['qSize']['qcy']
+        height = int(math.floor(10000 / no_of_columns))
+
+        # Extract the dimension and measure titles and concat them to column names.
+        dimension_titles = [dim['qFallbackTitle'] for dim in obj_layout['qHyperCube']['qDimensionInfo']]
+        measure_titles = [measure['qFallbackTitle'] for measure in obj_layout['qHyperCube']['qMeasureInfo']]
+        column_names = dimension_titles + measure_titles
+
+        # if the type of the charts has a straight data structure
+        if (obj_layout['qInfo']['qType'] in ['table', 'sn-table', 'piechart', 'scatterplot', 'combochart', 'barchart']
+                and obj_layout['qHyperCube']['qDataPages'] != []):
+
+            # Paging variables
+            page = 0
+            data_values = []
+
+            # 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)
+                hc_data = self.egoa.get_hypercube_data(obj_handle, '/qHyperCubeDef', nx_page)[
+                    'qDataPages'][0]['qMatrix']
+                data_values.extend(hc_data)
+                page += 1
+
+            # Creates Dataframe from the content of the attribute 'qText'.
+            df = pd.DataFrame([[d['qText'] for d in sublist] for sublist in data_values])
+
+            # Assign titles zu Dataframe columns
+            df.columns = column_names
+
+        # if the type of the charts has a pivot data structure
+        elif (obj_layout['qInfo']['qType'] in ['pivot-table', 'sn-pivot-table']
+              and obj_layout['qHyperCube']['qPivotDataPages'] != []):
+
+            # Supporting function to traverse all subnodes to get all dimensions
+            def get_all_dimensions(node):
+                dimensions = [node['qText']]
+                # if 'qSubNodes' in node and node['qSubNodes']:
+                if node['qSubNodes']:
+                    sub_dimensions = []
+                    for sub_node in node['qSubNodes']:
+                        sub_dimensions.extend([dimensions + d for d in get_all_dimensions(sub_node)])
+                    return sub_dimensions
+                else:
+                    return [dimensions]
+
+            # Gets the column headers for the pivot table
+            col_headers = []
+            nx_page_top = self.structs.nx_page(0, 0, width, 1)
+            hc_top = self.egoa.get_hypercube_pivot_data(obj_handle, '/qHyperCubeDef', nx_page_top)[
+                'qDataPages'][0]['qTop']
+            for top_node in hc_top:
+                col_headers.extend(get_all_dimensions(top_node))
+
+            # Paging variables
+            page = 0
+            row_headers = []
+            data_values = []
+
+            # 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)
+
+                # Retrieves the row headers for the pivot table
+                hc_left = self.egoa.get_hypercube_pivot_data(obj_handle, '/qHyperCubeDef', nx_page)[
+                    'qDataPages'][0]['qLeft']
+                for left_node in hc_left:
+                    row_headers.extend(get_all_dimensions(left_node))
+
+                # Retrieves the data for the pivot table
+                hc_data = self.egoa.get_hypercube_pivot_data(obj_handle, '/qHyperCubeDef', nx_page)[
+                    'qDataPages'][0]['qData']
+                for row in hc_data:
+                    data_values.append([cell['qText'] for cell in row])
+
+                page += 1
+
+            # Creates multi indes for rows and columns
+            row_index = pd.MultiIndex.from_tuples(row_headers)
+            col_index = pd.MultiIndex.from_tuples(col_headers)
+
+            # Creates the Dataframe
+            df = pd.DataFrame(data_values, index=row_index, columns=col_index)
+
+        # 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)
+            hc_data = self.egoa.get_hypercube_stack_data(obj_handle, '/qHyperCubeDef', nx_page, max_no_cells)[
+                'qDataPages'][0]['qData'][0]['qSubNodes']
+
+            # Transform the nested structure into a flat DataFrame
+            data_values = []
+            for node in hc_data:
+                for sub_node in node['qSubNodes']:
+                    value = sub_node['qSubNodes'][0]['qValue'] if sub_node['qSubNodes'] else None
+                    data_values.append([node['qText'], sub_node['qText'], value])
+
+            # Creates the Dataframe
+            df = pd.DataFrame(data_values, columns=column_names)
+
+        else:
+            return 'Chart type not supported.'
+
+        # Returns the Dataframe
+        return df
+
+    def get_constructed_table_data(self, app_handle, list_of_dimensions = [], list_of_measures = [],
+                                  list_of_master_dimensions = [], list_of_master_measures = []):
+        """
+        Creates a table from given fields, expressions, dimensions or measures and retrieves the data from it.
+
+        Parameters:
+            app_handle (int): The handle of the app.
+            list_of_dimensions (list): A list of dimensions.
+            list_of_measures (list): A list of measures.
+            list_of_master_dimensions (list): A list of master dimensions.
+            list_of_master_measures (list): A list of master measures.
+
+        Returns:
+        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))
+        for dimension in list_of_master_dimensions:
+            hc_dim.append(self.structs.nx_dimension(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))
+        for measure in list_of_master_measures:
+            hc_mes.append(self.structs.nx_measure(measure))
+
+        # Create hypercube structure
+        hc_def = self.structs.hypercube_def("$", hc_dim, hc_mes)
+
+        # Create info structure
+        nx_info = self.structs.nx_info("table")
+
+        # Create generic object properties structure
+        gen_obj_props = self.structs.generic_object_properties(nx_info, "qHyperCubeDef", hc_def)
+
+        # Create session object
+        hc_obj = self.eaa.create_session_object(app_handle, gen_obj_props)
+
+        # Get object handle
+        hc_obj_handle = self.get_handle(hc_obj)
+
+        # Get object layout
+        hc_obj_layout = self.egoa.get_layout(hc_obj_handle)
+
+        # Determine the number of the columns and the rows the table has and splits in certain circumstances the table calls
+        no_of_columns = hc_obj_layout['qHyperCube']['qSize']['qcx']
+        width = no_of_columns
+        no_of_rows = hc_obj_layout['qHyperCube']['qSize']['qcy']
+        height = int(math.floor(10000 / no_of_columns))
+
+        # Extract the dimension and measure titles and concat them to column names.
+        dimension_titles = [dim['qFallbackTitle'] for dim in hc_obj_layout['qHyperCube']['qDimensionInfo']]
+        measure_titles = [measure['qFallbackTitle'] for measure in hc_obj_layout['qHyperCube']['qMeasureInfo']]
+        column_names = dimension_titles + measure_titles
+
+        # Paging variables
+        page = 0
+        data_values = []
+
+        # 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)
+            hc_data = self.egoa.get_hypercube_data(hc_obj_handle, '/qHyperCubeDef', nx_page)['qDataPages'][0]['qMatrix']
+            data_values.extend(hc_data)
+            page += 1
+
+        # Creates Dataframe from the content of the attribute 'qText'.
+        df = pd.DataFrame([[d['qText'] for d in sublist] for sublist in data_values])
+
+        # Assign titles zu Dataframe columns
+        df.columns = column_names
+
+        # Returns the Dataframe
+        return df

qe_api_client/engine_helper.py

@@ -1,10 +1,10 @@
 import math
 
-from qe_api_client.engine_app_api import EngineAppApi
-from qe_api_client.engine_field_api import EngineFieldApi
-from qe_api_client.engine_generic_object_api import EngineGenericObjectApi
-from qe_api_client.engine_global_api import EngineGlobalApi
-from qe_api_client.structs import Structs
+from qe_api_client.api_classes.engine_app_api import EngineAppApi
+from qe_api_client.api_classes.engine_field_api import EngineFieldApi
+from qe_api_client.api_classes.engine_generic_object_api import EngineGenericObjectApi
+from qe_api_client.api_classes.engine_global_api import EngineGlobalApi
+import qe_api_client.structs as structs
 
 import pandas as pd
 
@@ -12,26 +12,26 @@ import pandas as pd
 def getDataFrame(connection, appHandle, measures, dimensions, selections={}):
     engineGlobalApi = EngineGlobalApi(connection)
     # Define Dimensions of hypercube
-    hc_inline_dim = Structs.nx_inline_dimension_def(dimensions)
+    hc_inline_dim = structs.nx_inline_dimension_def(dimensions)
 
     # Set sorting of Dimension by Measure
-    hc_mes_sort = Structs.nx_sort_by()
+    hc_mes_sort = structs.sort_criteria()
 
     # Define Measure of hypercube
-    hc_inline_mes = Structs.nx_inline_measure_def(measures)
+    hc_inline_mes = structs.nx_inline_measure_def(measures)
 
     # Build hypercube from above definition
-    hc_dim = Structs.nx_hypercube_dimensions(hc_inline_dim)
-    hc_mes = Structs.nx_hypercube_measure(hc_mes_sort, hc_inline_mes)
+    hc_dim = structs.nx_dimension(hc_inline_dim)
+    hc_mes = structs.nx_measure("", hc_inline_mes, hc_mes_sort)
 
     width = len(measures) + len(dimensions)
     height = int(math.floor(10000 / width))
-    nx_page = Structs.nx_page(0, 0, height, width)
-    hc_def = Structs.hypercube_def("$", hc_dim, hc_mes, [nx_page])
+    nx_page = structs.nx_page(0, 0, width, height)
+    hc_def = structs.hypercube_def("$", [hc_dim], [hc_mes], [nx_page])
 
     engineAppApi = EngineAppApi(connection)
     hc_response = engineAppApi.create_object(appHandle, "CH01", "Chart", "qHyperCubeDef", hc_def)  # NOQA
-    hc_handle = engineGlobalApi.get_handle(hc_response)
+    hc_handle = engineGlobalApi.get_handle(hc_response['qReturn'])
 
     engineGenericObjectApi = EngineGenericObjectApi(connection)
 
@@ -47,8 +47,8 @@ def getDataFrame(connection, appHandle, measures, dimensions, selections={}):
 
     i = 0
     while i % height == 0:
-        nx_page = Structs.nx_page(i, 0, height, width)
-        hc_data = engineGenericObjectApi.get_hypercube_data(hc_handle, "/qHyperCubeDef", [nx_page])  # NOQA
+        nx_page = structs.nx_page(0, i, width, height)
+        hc_data = engineGenericObjectApi.get_hypercube_data(hc_handle, "/qHyperCubeDef", nx_page)  # NOQA
         elems = hc_data["qDataPages"][0]['qMatrix']
 
         df = pd.DataFrame()

qe_api_client/structs.py

@@ -1,107 +1,58 @@
-class Structs:
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def list_object_def(state_name="$", library_id="",
-                        field_defs=None, field_labels=None,
-                        sort_criterias=None, initial_data_fetch=None
-                        ):
-        if initial_data_fetch is None:
-            initial_data_fetch = []
-        if sort_criterias is None:
-            sort_criterias = []
-        if field_labels is None:
-            field_labels = []
-        if field_defs is None:
-            field_defs = []
-        return {"qStateName": state_name,
-                "qLibraryId": library_id,
-                "qDef": {
-                    "qFieldDefs": field_defs,
-                    "qFieldLabels": field_labels,
-                    "qSortCriterias": sort_criterias
-                },
-                "qInitialDataFetch": initial_data_fetch
-                }
-
-    @staticmethod
-    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,  # NxDimensions
-                "qMeasures": nx_meas,  # NxMeasure
-                "qInterColumnSortOrder": inter_column_sort,
-                "qSuppressZero": suppress_zero,
-                "qSuppressMissing": suppress_missing,
-                "qInitialDataFetch": nx_page,  # NxPage
-                "qMode": 'S',
-                "qNoOfLeftDims": -1,
-                "qAlwaysFullyExpanded": False,
-                "qMaxStackedCells": 5000,
-                "qPopulateMissing": False,
-                "qShowTotalsAbove": False,
-                "qIndentMode": False,
-                "qCalcCond": "",
-                "qSortbyYValue": 0
-                }
-
-    @staticmethod
-    def nx_hypercube_dimensions(dim_def):
-        return {"qLibraryId": "",
-                "qNullSuppression": False,
-                "qDef": dim_def
-                }
-
-    @staticmethod
-    def nx_inline_dimension_def(field_definitions=[],
-                                grouping='N',
-                                field_labels=[]
-                                ):
-        return {"qGrouping": grouping,
-                "qFieldDefs": field_definitions,
-                "qFieldLabels": field_labels
-                }
-
-    @staticmethod
-    def nx_hypercube_measure(sort_by={}, nx_inline_measures_def=""):
-        return {"qSortBy": sort_by,
-                "qDef": nx_inline_measures_def
-                }
-
-    @staticmethod
-    def nx_sort_by(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": ""
-                    }
-                }
-
-    @staticmethod
-    def nx_inline_measure_def(definition, label="",
-                              description="",
-                              tags=[],
-                              grouping="N"
-                              ):
-        return {"qLabel": label,
-                "qDescription":	description,
-                "qTags": tags,
-                "qGrouping": grouping,
-                "qDef":	definition
-                }
-
-    @staticmethod
-    def nx_page(top=0, left=0, height=2, width=2):
-        return {"qTop": top,
-                "qLeft": left,
-                "qHeight": height,
-                "qWidth": width
-                }
+def list_object_def(state_name="$", library_id="", field_defs=None, field_labels=None, sort_criterias=None,
+                    initial_data_fetch=None):
+    if initial_data_fetch is None:
+        initial_data_fetch = []
+    if sort_criterias is None:
+        sort_criterias = []
+    if field_labels is None:
+        field_labels = []
+    if field_defs is None:
+        field_defs = []
+    return {"qStateName": state_name, "qLibraryId": library_id,
+            "qDef": {"qFieldDefs": field_defs, "qFieldLabels": field_labels, "qSortCriterias": sort_criterias},
+            "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,
+            "qInterColumnSortOrder": inter_column_sort, "qSuppressZero": suppress_zero,
+            "qSuppressMissing": suppress_missing, "qInitialDataFetch": nx_page, "qMode": 'S', "qNoOfLeftDims": -1,
+            "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
+        sets another one. If an identifier is not set, the engine automatically sets one. This parameter is optional.
+
+    Returns:
+        dict: Struct "nxInfo"
+    """
+    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": ""}}

{qe_api_client-1.2.0.dist-info → qe_api_client-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qe-api-client
-Version: 1.2.0
+Version: 2.1.0
 Summary: Python wrapper around Qlik Engine JSON API
 Home-page: https://github.com/lr-bicc/qe-api-client
 Author: Rumen Vasilev
@@ -13,7 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: websocket-client >=0.47.0
 
-# pyqlikengine
+# 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)
 
@@ -23,10 +23,15 @@ Forked from [jhettler/pyqlikengine](https://github.com/jhettler/pyqlikengine)
 * Python 3.6+
 * websocket-client>=0.47.0
 
-## Example of usage
+## Installation
 ```bash
 pip install qe-api-client
 ```
+
+## Example of usage on Qlik Sense Enterprise Server
+You need to export the Qlik Sense certificates in PEM format from the Qlik Sense Enterprise server to a local folder in 
+order to authenticate on the server.
+
 ```python
 from qe_api_client.engine import QixEngine
 
@@ -36,10 +41,25 @@ user_id = 'sense'
 ca_certs = 'qlik_certs/qlik-1_root.pem'
 certfile = 'qlik_certs/qlik-1_client.pem'
 keyfile = 'qlik_certs/qlik-1_client_key.pem'
-qixe = QixEngine(url=url, user_directory=user_directory,
-                 user_id=user_id, ca_certs=ca_certs,
-                 certfile=certfile, keyfile=keyfile)
+qixe = QixEngine(url=url, user_directory=user_directory, user_id=user_id, ca_certs=ca_certs, certfile=certfile, 
+                 keyfile=keyfile)
+
+# print all apps in Qlik Server
+print(qixe.ega.get_doc_list())
+```
+
+## Example of usage on Qlik Sense Desktop
+You need to start your Qlik Sense Desktop client on your local PC.
+
+```python
+from qe_api_client.engine import QixEngine
+
+url = 'ws://localhost:4848/app'
+qixe = QixEngine(url=url)
 
 # print all apps in Qlik Server
 print(qixe.ega.get_doc_list())
 ```
+
+## API reference
+Please click on this [link](https://lr-bicc.github.io/qe-api-client) for full API reference documentation .