qe-api-client 2.0.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

qe_api_client/api_classes/engine_app_api.py

@@ -141,10 +141,10 @@ class EngineAppApi:
         Parameters:
             doc_handle (int): The handle identifying the app document.
             field_name (str): The name of the field to retrieve.
-            state_name (str): The name of the state. Default is an empty string, indicating the default state.
+            state_name (str): The name of the alternate state. Default state is current selections.
 
         Returns:
-            dict: The retrieved field (qReturn). In case of an error, returns the error information.
+            dict: Object interface.
         """
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "GetField",
                           "params": {"qFieldName": field_name, "qStateName": state_name}})
@@ -154,22 +154,19 @@ class EngineAppApi:
         except KeyError:
             return response['error']
 
-    def create_object(self, doc_handle, q_id="LB01", q_type="ListObject", struct_name="qListObjectDef", ob_struct={}):
+    def create_object(self, doc_handle, prop):
         """
         Creates a new object in the app identified by the document handle.
 
         Parameters:
             doc_handle (int): The handle identifying the app document.
-            q_id (str): The ID of the new object. Default is "LB01".
-            q_type (str): The type of the new object. Default is "ListObject".
-            struct_name (str): The name of the structure defining the object. Default is "qListObjectDef".
-            ob_struct (dict): The structure defining the object.
+            prop (dict): Information about the object.
 
         Returns:
             dict: The created object (qReturn). In case of an error, returns the error information.
         """
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "method": "CreateObject", "handle": doc_handle,
-                          "params": [{"qInfo": {"qId": q_id, "qType": q_type}, struct_name: ob_struct}]})
+                          "params": {"qProp": prop}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response['result']['qReturn']
@@ -223,8 +220,16 @@ class EngineAppApi:
             return response['error']
 
     def clear_all(self, doc_handle, locked_also=False, alt_state=""):
+        """
+        Clear selections in fields for current state. Locked fields are not cleared by default.
+
+        Parameters:
+            doc_handle (int): The handle identifying the app document.
+            locked_also (bool): When true, clears the selection for locked fields.
+            alt_state (str): Alternate state name. When set, applies to alternate state instead of current.
+        """
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "ClearAll",
-                          "params": [locked_also, alt_state]})
+                          "params": {"qLockedAlso": locked_also, "qStateName": alt_state}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response['result']
@@ -250,45 +255,24 @@ class EngineAppApi:
     # can contain the same dimension.
     # Parameters:
     # qProp (MANDATORY: send dim_id, dim_title, dim_grouping, dim_field, dim_label, meta_def (optional)  # NOQA
-    def create_master_dim(self, doc_handle, dim_id, dim_title,
-                          dim_grouping="N", dim_field='', dim_label='',
-                          meta_def=""):
+    def create_dimension(self, doc_handle, prop):
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "CreateDimension",
-                          "params": [{
-                                "qInfo": {
-                                    "qId": dim_id,
-                                    "qType": "Dimension"
-                                },
-                                "qDim": {
-                                    "title": dim_title,
-                                    "qGrouping": dim_grouping,
-                                    "qFieldDefs": [
-                                        dim_field
-                                    ],
-                                    "qFieldLabels": [
-                                        dim_label
-                                    ]
-                                },
-                                "qMetaDef": {
-                                    "title": meta_def
-                                }
-                            }]
-                          })
+                          "params": {"qProp": prop}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
-            return response['result']
+            return response["result"]["qReturn"]
         except KeyError:
             return response['error']
 
     # DestroyDimension method: Removes a dimension
-    def destroy_dim(self, doc_handle, dim_id):
+    def destroy_dimension(self, doc_handle, dim_id):
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "DestroyDimension",
-                          "params": [{dim_id}]})
+                          "params": {"qId": dim_id}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
-            return response['result']
+            return response["result"]["qSuccess"]
         except KeyError:
-            return response['error']
+            return response["error"]
 
     # DestroyMeasure method: Removes a measure
     def destroy_measure(self, doc_handle, measure_id):
@@ -347,25 +331,12 @@ class EngineAppApi:
     # can contain the same dimension.
     # Parameters:
     # qProp (MANDATORY: send dim_id, dim_title, dim_grouping, dim_field, dim_label, meta_def (optional)  # NOQA
-    def create_master_measure(self, doc_handle, measure_id, measure_title, measure_expr, meta_def=""):
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle,
-                          "method": "CreateMeasure", "params": [{
-                                "qInfo": {
-                                    "qId": measure_id,
-                                    "qType": "Measure"
-                                },
-                                "qMeasure": {
-                                    "qLabel": measure_title,
-                                    "qDef": measure_expr
-                                },
-                                "qMetaDef": {
-                                    "title": measure_title
-                                }
-                            }]
-                          })
+    def create_measure(self, doc_handle, prop):
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "CreateMeasure",
+                          "params": {"qProp": prop}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
-            return response['result']
+            return response["result"]["qReturn"]
         except KeyError:
             return response['error']
 
@@ -702,9 +673,9 @@ class EngineAppApi:
         except KeyError:
             return response['error']
 
-    def create_session_object(self, doc_handle, param):
+    def create_session_object(self, doc_handle, prop):
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": doc_handle, "method": "CreateSessionObject",
-                          "params": [param]})
+                          "params": {"qProp": prop}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response['result']['qReturn']

qe_api_client/api_classes/engine_field_api.py

@@ -18,77 +18,87 @@ class EngineFieldApi:
         """
         self.engine_socket = socket
 
-    def select(self, fld_handle, value):
+    def select(self, fld_handle, value, soft_lock = False, excluded_values_mode = 0):
         """
-        Selects a specific value in a field.
+        Selects field values matching a search string.
 
         Args:
             fld_handle (int): The handle of the field.
-            value (str): The value to select.
+            value (str): String to search for. Can contain wild cards or numeric search criteria.
+            soft_lock (bool): Set to true to ignore locks; in that case, locked fields can be selected.
+            excluded_values_mode (int): Include excluded values in search.
 
         Returns:
             dict: The response from the engine, containing the result or an error message.
         """
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "Select",
-                          "params": [value, False, 0]})
+                          "params": {"qMatch": value, "qSoftLock": soft_lock,
+                                     "qExcludedValuesMode": excluded_values_mode}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response
         except KeyError:
             return response["error"]
 
-    def select_values(self, fld_handle, values=None):
+    def select_values(self, fld_handle, values, toggle_mode = False, soft_lock = False):
         """
         Selects multiple values in a field.
 
         Args:
             fld_handle (int): The handle of the field.
-            values (list, optional): A list of values to select. Defaults to an empty list.
+            values (list): A list of field values to select. Mandatory field.
+            toggle_mode (bool): The default value is false.
+            soft_lock (bool): Set to true to ignore locks; in that case, locked fields can be selected.
+            The default value is false.
 
         Returns:
             dict: The response from the engine, containing the result or an error message.
         """
-        if values is None:
-            values = []
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "SelectValues",
-                          "params": [values, False, False]})
+                          "params": {"qFieldValues": values, "qToggleMode": toggle_mode, "qSoftLock": soft_lock}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
-            return response
+            return response["result"]["qReturn"]
         except KeyError:
             return response["error"]
 
-    def select_excluded(self, fld_handle):
+    def select_excluded(self, fld_handle, soft_lock=False):
         """
-        Selects all excluded values in a field.
+        Inverts the current selections.
 
         Args:
             fld_handle (int): The handle of the field.
+            soft_lock (bool): Set to true to ignore locks; in that case, locked fields can be selected.
+            The default value is false.
 
         Returns:
-            dict: The response from the engine, containing the result or an error message.
+            bool: true/false. The operation is successful if qReturn is set to true.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "SelectExcluded", "params": []})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "SelectExcluded",
+                          "params": {"qSoftLock": soft_lock}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
-            return response["result"]
+            return response["result"]["qReturn"]
         except KeyError:
             return response["error"]
 
-    def select_possible(self, fld_handle):
+    def select_possible(self, fld_handle, soft_lock=False):
         """
         Selects all possible values in a field.
 
         Args:
             fld_handle (int): The handle of the field.
+            soft_lock (bool): Set to true to ignore locks; in that case, locked fields can be selected.
+            The default value is false.
 
         Returns:
-            dict: The response from the engine, containing the result or an error message.
+            bool: true/false. The operation is successful if qReturn is set to true.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "SelectPossible", "params": []})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "SelectPossible",
+                          "params": {"qSoftLock": soft_lock}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
-            return response["result"]
+            return response["result"]["qReturn"]
         except KeyError:
             return response["error"]
 
@@ -102,7 +112,7 @@ class EngineFieldApi:
         Returns:
             dict: The response from the engine, containing the result or an error message.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "Clear", "params": []})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "Clear", "params": {}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response["result"]
@@ -119,9 +129,9 @@ class EngineFieldApi:
         Returns:
             int: The number of distinct values in the field, or an error message.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "GetCardinal", "params": []})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": fld_handle, "method": "GetCardinal", "params": {}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
-            return response["result"]
+            return response["result"]["qReturn"]
         except KeyError:
             return response["error"]

qe_api_client/api_classes/engine_generic_object_api.py

@@ -7,6 +7,7 @@ class EngineGenericObjectApi:
     data visualization objects.
 
     Methods:
+        create_child(handle, params): Creates a generic object that is a child of another generic object.
         get_layout(handle): Retrieves the layout structure of a generic object.
         get_full_property_tree(handle): Retrieves the full property tree of a generic object.
         get_effective_properties(handle): Retrieves the effective properties of a generic object.
@@ -23,6 +24,23 @@ class EngineGenericObjectApi:
             socket (object): The socket connection to the Qlik Sense engine.
         """
         self.engine_socket = socket
+    def create_child(self, handle, params):
+        """
+        Retrieves the layout structure of a specific generic object.
+
+        Parameters:
+            handle (int): The handle identifying the generic object.
+            params (str): The parameters of the generic object.
+
+        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": [params]})
+        response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
+        try:
+            return response["result"]
+        except KeyError:
+            return response["error"]
 
     def get_layout(self, handle):
         """
@@ -76,7 +94,7 @@ class EngineGenericObjectApi:
         except KeyError:
             return response["error"]
 
-    def get_hypercube_data(self, handle, path="/qHyperCubeDef", pages=[]):
+    def get_hypercube_data(self, handle, path="/qHyperCubeDef", pages={}):
         """
         Retrieves the data from a specific hypercube in a generic object.
 
@@ -89,14 +107,14 @@ class EngineGenericObjectApi:
             dict: The data from the hypercube. In case of an error, returns the error information.
         """
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "GetHyperCubeData",
-                          "params": [path, pages]})
+                          "params": {"qPath": path, "qPages": [pages]}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response["result"]
         except KeyError:
             return response["error"]
 
-    def get_hypercube_pivot_data(self, handle, path="/qHyperCubeDef", pages=[]):
+    def get_hypercube_pivot_data(self, handle, path="/qHyperCubeDef", pages={}):
         """
         Retrieves the pivot data from a specific hypercube in a generic object.
 
@@ -108,16 +126,15 @@ class EngineGenericObjectApi:
         Returns:
             dict: The pivot data from the hypercube. In case of an error, returns the error information.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle,
-                          "method": "GetHyperCubePivotData",
-                          "params": [path, pages]})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "GetHyperCubePivotData",
+                          "params": {"qPath": path, "qPages": [pages]}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response["result"]
         except KeyError:
             return response["error"]
 
-    def get_hypercube_stack_data(self, handle, path="/qHyperCubeDef", pages=[], max_no_cells=10000):
+    def get_hypercube_stack_data(self, handle, path="/qHyperCubeDef", pages={}, max_no_cells=10000):
         """
         Retrieves the values of a stacked pivot table. It is possible to retrieve specific pages of data.
 
@@ -132,7 +149,7 @@ class EngineGenericObjectApi:
             dict: The pivot data from the hypercube. In case of an error, returns the error information.
         """
         msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "GetHyperCubeStackData",
-                          "params": [path, pages, max_no_cells]})
+                          "params": {"qPath": path, "qPages": [pages], "qMaxNbrCells": max_no_cells}})
         response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
         try:
             return response["result"]

qe_api_client/api_classes/engine_global_api.py

@@ -85,7 +85,8 @@ class EngineGlobalApi:
         Returns:
         dict: Information about the deletion result.
         """
-        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": -1, "method": "DeleteApp", "params": [app_name]})
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": -1, "method": "DeleteApp",
+                          "params": {"qAppId": app_name}})
         response = json.loads(
             self.engine_socket.send_call(self.engine_socket, msg))
         try:

qe_api_client/engine.py

@@ -12,6 +12,12 @@ import pandas as pd
 
 
 class QixEngine:
+    """
+    The class of the client to interact with the Qlik Sense Engine API.
+
+    Methods:
+        select_in_dimension(app_handle, dimension_name, list_of_values): Selects values in a given field.
+    """
 
     def __init__(self, url, user_directory=None, user_id=None, ca_certs=None, certfile=None, keyfile=None, app_id=None):
         self.url = url
@@ -33,112 +39,62 @@ class QixEngine:
         self.structs = structs
         self.app_handle = ''
 
-    def create_app(self, app_name='my_app'):
-        app = self.ega.create_app(app_name)
-        try:
-            return app['qAppId']
-        except KeyError:
-            return app['message']
-
-    def load_script(self, script):
-        self.eaa.set_script(self.app_handle, script)
-        return self.eaa.do_reload_ex(self.app_handle)['qResult']['qSuccess']
-
-    def open_app(self, app_obj):
-        opened_app = self.ega.open_doc(app_obj)
-        self.app_handle = self.ega.get_handle(opened_app)
-        return opened_app['qGenericId']
-
-    def create_hypercube(self, doc_handle, 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, no_of_columns, rows_to_return)
-        hc_def = self.structs.hypercube_def("$", hc_dim, hc_mes, [nx_page])
-        hc_response = self.eaa.create_object(doc_handle, "CH01", "Chart", "qHyperCubeDef", hc_def)
-        hc_handle = self.ega.get_handle(hc_response)
-        # 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)
+    def select_in_dimension(self, app_handle, dimension_name, list_of_values):
+        lb_field = self.eaa.get_field(app_handle, dimension_name)
+        fld_handle = self.get_handle(lb_field)
         values_to_select = []
         for val in list_of_values:
-            val = {'qText': val}
-            values_to_select.append(val)
+            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, dimension_name):
-        lb_field = self.eaa.get_field(self.app_handle, dimension_name)
-        fld_handle = self.ega.get_handle(lb_field)
+    def select_excluded_in_dimension(self, app_handle, dimension_name):
+        lb_field = self.eaa.get_field(app_handle, dimension_name)
+        fld_handle = self.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)
+    def select_possible_in_dimension(self, app_handle, dimension_name):
+        lb_field = self.eaa.get_field(app_handle, dimension_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, dimension_name):
-        lb_field = self.eaa.get_field(self.app_handle, dimension_name)
-        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
+    def get_list_object_data(self, app_handle, dimension_name):
+        lb_field = self.eaa.get_field(app_handle, dimension_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))
+        lb_def = self.structs.list_object_def("$", "", nx_inline_dimension_def,
+                                              [nx_page])
+
+        # Create info structure
+        nx_info = self.structs.nx_info("ListObject", "SLB01")
+
+        # Create generic object properties structure
+        gen_obj_props = self.structs.generic_object_properties(nx_info, "qListObjectDef", 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
         val_n_state_list = []
         for val in val_list:
             val_n_state_list.append((val[0]["qText"], val[0]["qState"]))
-        return val_n_state_list
 
-    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)
-        return self.efa.clear(fld_handle)['qReturn']
+        return val_n_state_list
 
-    def clear_all_selections(self):
-        return self.eaa.clear_all(self.app_handle, True)
+    def clear_selection_in_dimension(self, app_handle, dimension_name):
+        lb_field = self.eaa.get_field(app_handle, dimension_name)
+        fld_handle = self.get_handle(lb_field)
+        return self.efa.clear(fld_handle)
 
-    def delete_app(self, app_name):
-        return self.ega.delete_app(app_name)['qSuccess']
+    def create_single_master_dimension(self, app_handle, dim_title, dim_def, dim_label):
+        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)
+        master_dim = self.eaa.create_dimension(app_handle, gen_dim_props)
+        return master_dim
 
     def disconnect(self):
         self.conn.close_qvengine_connection(self.conn)
@@ -163,23 +119,19 @@ class QixEngine:
         except ValueError:
             return "Bad handle value in " + obj
 
-    def get_chart_data(self, doc_handle, obj_id):
+    def get_chart_data(self, app_handle, obj_id):
         """
         Retrieves the data from a given chart object.
 
         Parameters:
-            doc_handle (int): The handle of the app.
+            app_handle (int): The handle of the app.
             obj_id (str): The ID of the chart object.
 
         Returns:
-        int: The handle value.
-
-        Raises:
-        ValueError: If the handle value is invalid.
+        DataFrame: A table of the chart content.
         """
-
         # Get object ID
-        obj = self.eaa.get_object(doc_handle, obj_id)
+        obj = self.eaa.get_object(app_handle, obj_id)
         if obj['qType'] is None:
             return 'Chart ID does not exists!'
 
@@ -212,7 +164,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)
-                hc_data = self.egoa.get_hypercube_data(obj_handle, '/qHyperCubeDef', [nx_page])[
+                hc_data = self.egoa.get_hypercube_data(obj_handle, '/qHyperCubeDef', nx_page)[
                     'qDataPages'][0]['qMatrix']
                 data_values.extend(hc_data)
                 page += 1
@@ -242,7 +194,7 @@ class QixEngine:
             # 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])[
+            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))
@@ -257,13 +209,13 @@ class QixEngine:
                 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])[
+                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])[
+                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])
@@ -281,8 +233,8 @@ class QixEngine:
         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']
+            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 = []
@@ -297,5 +249,85 @@ class QixEngine:
         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

@@ -4,7 +4,7 @@ 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
-from qe_api_client.structs import Structs
+import qe_api_client.structs as structs
 
 import pandas as pd
 
@@ -12,22 +12,22 @@ 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, width, height)
-    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
@@ -47,8 +47,8 @@ def getDataFrame(connection, appHandle, measures, dimensions, selections={}):
 
     i = 0
     while i % height == 0:
-        nx_page = Structs.nx_page(0, i, width, height)
-        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,81 +1,69 @@
-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},
+def list_object_def(state_name="$", library_id="", field_defs=[], initial_data_fetch=[]):
+    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,  # 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
-            }
-
-
-def nx_hypercube_dimensions(dim_def):
-    return {"qLibraryId": "", "qNullSuppression": False, "qDef": dim_def}
-
-
-def nx_inline_dimension_def(field_definitions=[], grouping='N', field_labels=[]):
-    return {"qGrouping": grouping,
-            "qFieldDefs": field_definitions,
-            "qFieldLabels": field_labels
-            }
-
-
-def nx_hypercube_measure(sort_by={}, nx_inline_measures_def=""):
-    return {"qSortBy": sort_by,
-            "qDef": nx_inline_measures_def
-            }
-
-
-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": ""
-                }
-            }
-
-
-def nx_inline_measure_def(definition, label="",
-                          description="",
-                          tags=[],
-                          grouping="N"
-                          ):
-    return {"qLabel": label,
-            "qDescription":	description,
-            "qTags": tags,
-            "qGrouping": grouping,
-            "qDef":	definition
-            }
+    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": ""}}
+
+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=""):
+    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={}):
+    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=""):
+    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}}

{qe_api_client-2.0.0.dist-info → qe_api_client-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qe-api-client
-Version: 2.0.0
+Version: 2.2.0
 Summary: Python wrapper around Qlik Engine JSON API
 Home-page: https://github.com/lr-bicc/qe-api-client
 Author: Rumen Vasilev

qe_api_client-2.2.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+qe_api_client/__init__.py,sha256=bypB4CIjpHtf5Pu_NwtJajC69zqQD7qB9jo8cCX0B54,23
+qe_api_client/engine.py,sha256=zK6FxdsxiFy3-IpZ664gcsoJU9dpTdVm4NWn6zgXa6E,14944
+qe_api_client/engine_communicator.py,sha256=Va8Kz4cN6uyKLzV3JllBw08KbU4uDn8e-5pIm5Kmsfs,1291
+qe_api_client/engine_helper.py,sha256=DSZR92-pGqklzki53QufgGr9tUTKKXZyF_fHEfXokTs,2382
+qe_api_client/structs.py,sha256=9oB8-APCIkt1nNtwRpqGGMvzF42SX2ep5r4zSrLkjL4,3999
+qe_api_client/api_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qe_api_client/api_classes/engine_app_api.py,sha256=3bQHufiKvWHOOKjX50WK7pbH-fM0Rz6WMblEgEjAn2I,36847
+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_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.2.0.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+qe_api_client-2.2.0.dist-info/METADATA,sha256=ZvtVqTUoNFA_a70UPxJWIjUptydO1Ij42w5Yy_hF8B0,1995
+qe_api_client-2.2.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+qe_api_client-2.2.0.dist-info/top_level.txt,sha256=m_43YagP8UtZgJHmZEfu0vlBNwt36M01-Qby2jByMnk,14
+qe_api_client-2.2.0.dist-info/RECORD,,

{qe_api_client-2.0.0.dist-info → qe_api_client-2.2.0.dist-info}/WHEEL

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

qe_api_client-2.0.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-qe_api_client/__init__.py,sha256=bypB4CIjpHtf5Pu_NwtJajC69zqQD7qB9jo8cCX0B54,23
-qe_api_client/engine.py,sha256=jG4YYLI_CJChimp76wJamgChJ-55YDMisKzmuRbPrew,13589
-qe_api_client/engine_communicator.py,sha256=Va8Kz4cN6uyKLzV3JllBw08KbU4uDn8e-5pIm5Kmsfs,1291
-qe_api_client/engine_helper.py,sha256=PU29TYs3V9yF54_IWTHD4O2qSSW-bcaayqH1LCsGFOc,2400
-qe_api_client/structs.py,sha256=vswDRzkH8YEG0v6GuFl6hXEnRaWkQzvnTBU1T_e1vkk,2813
-qe_api_client/api_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qe_api_client/api_classes/engine_app_api.py,sha256=UtlB_ctSDZYMMiGmpiAU9jIyUPM4f2ybyK5i3bHpRRs,38423
-qe_api_client/api_classes/engine_field_api.py,sha256=KiFhs2ev3S-92JklWzIVtfTEZ1oCiHEAanm1AXtV38s,4407
-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_object_api.py,sha256=5pKcbti1tJSKLuacw-nXKMDXH-MlCNr12BoeE40F0OE,7311
-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=SdzhIP6Isco83xB1Y6y3LHKv-HjBTS_iMh-QdVYAl4g,27499
-qe_api_client-2.0.0.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-qe_api_client-2.0.0.dist-info/METADATA,sha256=OxDu8jkrUtxmLTUxYH-qBUNYdhTS46CpWPqAysK_CFM,1995
-qe_api_client-2.0.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-qe_api_client-2.0.0.dist-info/top_level.txt,sha256=m_43YagP8UtZgJHmZEfu0vlBNwt36M01-Qby2jByMnk,14
-qe_api_client-2.0.0.dist-info/RECORD,,