qe-api-client 2.1.0__tar.gz → 2.2.0__tar.gz

{qe_api_client-2.1.0 → qe_api_client-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qe-api-client
-Version: 2.1.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.1.0 → qe_api_client-2.2.0}/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}})
@@ -160,10 +160,7 @@ class EngineAppApi:
 
         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.
@@ -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']
 

{qe_api_client-2.1.0 → qe_api_client-2.2.0}/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-2.1.0 → qe_api_client-2.2.0}/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-2.1.0 → qe_api_client-2.2.0}/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,68 +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 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']
-
-    def clear_all_selections(self):
-        return self.eaa.clear_all(self.app_handle, True)
+        return val_n_state_list
 
-    def delete_app(self, app_name):
-        return self.ega.delete_app(app_name)['qSuccess']
+    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 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)

{qe_api_client-2.1.0 → qe_api_client-2.2.0}/qe_api_client/structs.py

@@ -1,15 +1,5 @@
-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,
@@ -56,3 +46,24 @@ def generic_object_properties(info, prop_name, prop_def, extends_id="", state_na
 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.1.0 → qe_api_client-2.2.0}/qe_api_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qe-api-client
-Version: 2.1.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.1.0 → qe_api_client-2.2.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="qe-api-client",
-    version="2.1.0",
+    version="2.2.0",
     author="Rumen Vasilev",
     author_email="R.Vasilev@LRWorld.com",
     description="Python wrapper around Qlik Engine JSON API",

{qe_api_client-2.1.0 → qe_api_client-2.2.0}/test/test_app_api.py

@@ -70,7 +70,7 @@ class TestAppApi(unittest.TestCase):
         first_element_number = hc_data["qDataPages"][0]["qMatrix"][0][0]["qElemNumber"]  # NOQA
         first_element_text = hc_data["qDataPages"][0]["qMatrix"][0][0]["qText"]  # NOQA
         self.assertTrue(first_element_number == 0,"Incorrect value in first element number")
-        self.assertTrue(first_element_text == 'C',"Incorrect value in first element text")
+        self.assertTrue(first_element_text == "A","Incorrect value in first element text")
 
     def tearDown(self):
         self.qixe.ega.delete_app(self.app)

qe_api_client-2.2.0/test/test_field_api.py

@@ -0,0 +1,60 @@
+import unittest
+
+from qe_api_client.api_classes.engine_app_api import EngineAppApi
+from qe_api_client.engine_communicator import EngineCommunicator
+from qe_api_client.api_classes.engine_field_api import EngineFieldApi
+from qe_api_client.api_classes.engine_global_api import EngineGlobalApi
+import qe_api_client.structs as structs
+from qe_api_client.engine import QixEngine
+
+from qe_api_client.api_classes.engine_generic_object_api import EngineGenericObjectApi
+
+
+class TestFieldApi(unittest.TestCase):
+
+    def setUp(self):
+        url = 'ws://localhost:4848/app'
+        self.qixe = QixEngine(url)
+        self.app = self.qixe.ega.create_app("test_app")["qAppId"]
+        opened_app = self.qixe.ega.open_doc(self.app)
+        with open('./test_data/ctrl00_script.qvs') as f:
+            script = f.read()
+        self.app_handle = self.qixe.get_handle(opened_app)
+        self.qixe.eaa.set_script(self.app_handle, script)
+        self.qixe.eaa.do_reload_ex(self.app_handle)
+
+        nx_inline_dimension_def = self.qixe.structs.nx_inline_dimension_def(["Alpha"])
+        nx_page_initial = structs.nx_page(0, 0, 1, 26)
+        lb_def = structs.list_object_def("$", "", nx_inline_dimension_def,[nx_page_initial])
+
+        # Create info structure
+        nx_info = structs.nx_info("ListObject", "SLB01")
+
+        # Create generic object properties structure
+        gen_obj_props = structs.generic_object_properties(nx_info, "qListObjectDef", lb_def)
+        listobj = self.qixe.eaa.create_session_object(self.app_handle, gen_obj_props)  # NOQA
+
+        self.lb_handle = self.qixe.get_handle(listobj)
+        self.qixe.egoa.get_layout(self.lb_handle)
+        self.lb_field = self.qixe.eaa.get_field(self.app_handle, "Alpha")
+        self.fld_handle = self.qixe.get_handle(self.lb_field)
+
+    def test_select_values(self):
+        values_to_select = [{'qText': 'A'}, {'qText': 'B'}, {'qText': 'C'}]
+        sel_res = self.qixe.efa.select_values(self.fld_handle, values_to_select)
+        self.assertTrue(sel_res is True,"Failed to perform selection")
+        val_mtrx = self.qixe.egoa.get_layout(self.lb_handle)["qListObject"]["qDataPages"][0]["qMatrix"]  # NOQA
+        self.assertEqual(val_mtrx[0][0]["qState"],"S","Failed to select first value")
+        self.assertEqual(val_mtrx[4][0]["qState"],"X","Failed to exclude fifth value")
+        self.qixe.eaa.clear_all(self.app_handle)
+        val_mtrx = self.qixe.egoa.get_layout(self.lb_handle)["qListObject"]["qDataPages"][0]["qMatrix"]  # NOQA
+        self.assertEqual(val_mtrx[0][0]["qState"],"O","Failed to clear selection")
+        self.assertEqual(val_mtrx[4][0]["qState"],"O","Failed to clear selection")
+
+    def tearDown(self):
+        self.qixe.ega.delete_app(self.app)
+        self.qixe.conn.close_qvengine_connection(self.qixe.conn)
+
+
+if __name__ == '__main__':
+    unittest.main()

qe_api_client-2.2.0/test/test_pyqlikengine.py

@@ -0,0 +1,62 @@
+import unittest
+from qe_api_client.engine import QixEngine
+
+
+class TestQixEngine(unittest.TestCase):
+
+    def setUp(self):
+        self.qixe = QixEngine('ws://localhost:4848/app')
+        self.app = self.qixe.ega.create_app("test_app")["qAppId"]
+        opened_app = self.qixe.ega.open_doc(self.app)
+        with open('./test_data/ctrl00_script.qvs') as f:
+            script = f.read()
+        self.app_handle = self.qixe.get_handle(opened_app)
+        self.qixe.eaa.set_script(self.app_handle, script)
+        self.assertTrue(self.qixe.eaa.do_reload_ex(self.app_handle)['qResult']['qSuccess'],'Failed to load script')
+
+    def test_select_clear_in_dimension(self):
+        select_result = self.qixe.select_in_dimension(self.app_handle, 'Alpha',['A', 'C', 'E'])
+        self.assertTrue(select_result, "Failed to select values")
+        self.assertTrue(self.qixe.clear_selection_in_dimension(self.app_handle, 'Alpha'),
+                        'Failed to clear selection')
+
+    def test_select_clear_all_in_dimension(self):
+        select_result = self.qixe.select_in_dimension(self.app_handle, 'Alpha', ['A', 'C', 'E'])
+        self.assertTrue(select_result, "Failed to select values")
+        self.qixe.eaa.clear_all(self.app_handle)
+
+    def test_select_excluded(self):
+        self.qixe.select_in_dimension(self.app_handle, 'Alpha',['A', 'C', 'E'])
+        select_result = self.qixe.select_excluded_in_dimension(self.app_handle, 'Alpha')
+        self.assertTrue(select_result,'Failed to select excluded')
+
+    def test_select_possible(self):
+        select_result = self.qixe.select_possible_in_dimension(self.app_handle, 'Alpha')
+        self.assertTrue(select_result,'Failed to select possible')
+
+    def test_get_list_object_data(self):
+        self.assertTrue(len(self.qixe.get_list_object_data(self.app_handle, 'Alpha')) == 2,
+                        'Failed to get value list')
+
+    def test_get_constructed_table_data(self):
+        dim_1 = self.qixe.create_single_master_dimension(self.app_handle, "Dim 1", "Dim1", "'Dimension 1'")
+        dim_2 = self.qixe.create_single_master_dimension(self.app_handle, "Dim 2", "Dim2", "'Dimension 2'")
+        dim_1_id = dim_1["qGenericId"]
+        dim_2_id = dim_2["qGenericId"]
+
+        list_of_dimensions = ["Dim3"]
+        list_of_master_dimensions = [dim_1_id, dim_2_id]
+        list_of_measures = ["Sum(Expression3)"]
+        list_of_master_measures = []
+        # list_of_master_measures = ["snmpR", "1ad7060c-56ec-46d1-b83a-ff1393e0b236"]
+
+        df = self.qixe.get_constructed_table_data(self.app_handle, list_of_dimensions, list_of_measures,
+                                             list_of_master_dimensions, list_of_master_measures)
+        print(df)
+
+    def tearDown(self):
+        self.assertTrue(self.qixe.ega.delete_app(self.app),'Failed to delete app')
+        self.qixe.conn.close_qvengine_connection(self.qixe.conn)
+
+if __name__ == '__main__':
+    unittest.main()

qe_api_client-2.1.0/test/test_field_api.py

@@ -1,71 +0,0 @@
-import unittest
-
-from qe_api_client.api_classes.engine_app_api import EngineAppApi
-from qe_api_client.engine_communicator import EngineCommunicator
-from qe_api_client.api_classes.engine_field_api import EngineFieldApi
-from qe_api_client.api_classes.engine_global_api import EngineGlobalApi
-import qe_api_client.structs as structs
-
-from qe_api_client.api_classes.engine_generic_object_api import EngineGenericObjectApi
-
-
-class TestFieldApi(unittest.TestCase):
-
-    def setUp(self):
-        url = 'ws://localhost:4848/app'
-        self.conn = EngineCommunicator(url)
-        self.ega = EngineGlobalApi(self.conn)
-        self.eaa = EngineAppApi(self.conn)
-        self.egoa = EngineGenericObjectApi(self.conn)
-        self.efa = EngineFieldApi(self.conn)
-        self.struct = structs
-        self.app = self.ega.create_app("TestApp")["qAppId"]
-        opened_app = self.ega.open_doc(self.app)
-        self.app_handle = self.ega.get_handle(opened_app)
-        with open('../test/test_data/ctrl00_script.qvs') as f:
-            script = f.read()
-        self.eaa.set_script(self.app_handle, script)
-        self.eaa.do_reload_ex(self.app_handle)
-        nx_page_initial = structs.nx_page(0, 0, 1, 26)
-        self.lb_def = structs.list_object_def("$", "",
-                                              ["Alpha"],
-                                              None,
-                                              None,
-                                              [nx_page_initial])
-        self.lb_param = {"qInfo": {"qId": "SLB01", "qType": "ListObject"},
-                         "qListObjectDef": self.lb_def}
-        self.lb_sobject = self.eaa.create_session_object(self.app_handle,
-                                                         self.lb_param)
-        self.lb_handle = self.ega.get_handle(self.lb_sobject)
-        self.egoa.get_layout(self.lb_handle)
-        self.lb_field = self.eaa.get_field(self.app_handle, "Alpha")
-        self.fld_handle = self.ega.get_handle(self.lb_field)
-
-    def test_select_values(self):
-        values_to_select = [{'qText': 'A'}, {'qText': 'B'}, {'qText': 'C'}]
-        sel_res = self.efa.select_values(self.fld_handle, values_to_select)
-        self.assertTrue(sel_res["qReturn"] is True,
-                        "Failed to perform selection")
-        val_mtrx = self.egoa.get_layout(self.lb_handle)["qListObject"]["qDataPages"][0]["qMatrix"]  # NOQA
-        self.assertEqual(val_mtrx[0][0]["qState"],
-                         "S",
-                         "Failed to select first value")
-        self.assertEqual(val_mtrx[4][0]["qState"],
-                         "X",
-                         "Failed to exclude fifth value")
-        self.eaa.clear_all(self.app_handle)
-        val_mtrx = self.egoa.get_layout(self.lb_handle)["qListObject"]["qDataPages"][0]["qMatrix"]  # NOQA
-        self.assertEqual(val_mtrx[0][0]["qState"],
-                         "O",
-                         "Failed to clear selection")
-        self.assertEqual(val_mtrx[4][0]["qState"],
-                         "O",
-                         "Failed to clear selection")
-
-    def tearDown(self):
-        self.ega.delete_app(self.app)
-        self.conn.close_qvengine_connection(self.conn)
-
-
-if __name__ == '__main__':
-    unittest.main()

qe_api_client-2.1.0/test/test_pyqlikengine.py

@@ -1,74 +0,0 @@
-import unittest
-from qe_api_client.engine import QixEngine
-
-
-class TestQixEngine(unittest.TestCase):
-
-    def setUp(self):
-        self.qixe = QixEngine('ws://localhost:4848/app')
-        app = self.qixe.create_app('test_app')
-        self.assertTrue(app.endswith('.qvf'), 'Failed to create app')
-        app_exists = self.qixe.create_app('test_app')
-        self.assertTrue(app_exists == "App already exists",
-                        'Failed to handle existing app exception')
-        self.opened_app = self.qixe.open_app(app)
-        with open('./test_data/ctrl00_script.qvs') as f:
-            script = f.read()
-        self.assertTrue(self.qixe.load_script(script), 'Failed to load script')
-
-    def test_create_hypercube(self):
-        hc = self.qixe.create_hypercube(1, ['Dim1', 'Dim2'],
-                                        ['=Sum(Expression1)',
-                                         '=Sum(Expression2)',
-                                         '=Sum(Expression3)'])
-        hc_cols = self.qixe.convert_hypercube_to_matrix(hc[0], hc[1])
-        self.assertTrue(len(hc_cols) == 5,
-                        'Failed to return proper number of columns')
-        self.inline_table = self.qixe.convert_hypercube_to_inline_table(hc[0], 'MyTable')  # NOQA
-        self.assertTrue(self.inline_table.startswith('MyTable'),
-                        'Failed to create inline statement from hypercube')
-        self.mtrx = self.qixe.convert_hypercube_to_matrix(hc[0], hc[1])
-        self.assertTrue(len(self.mtrx) == 5,
-                        'Failed to create matrix from hypercube')
-
-    def test_select_clear_in_dimension(self):
-        select_result = self.qixe.select_in_dimension('Alpha',
-                                                      ['A', 'C', 'E'])
-        self.assertTrue(select_result["change"] == [1, 2],
-                        "Failed to select values")
-        self.assertTrue(select_result["result"]['qReturn'],
-                        "Failed to select values")
-        self.assertTrue(self.qixe.clear_selection_in_dimension('Alpha'),
-                        'Failed to clear selection')
-
-    def test_select_clear_all_in_dimension(self):
-        select_result = self.qixe.select_in_dimension('Alpha', ['A', 'C', 'E'])
-        self.assertTrue(select_result["change"] == [1, 2],
-                        "Failed to select values")
-        self.assertTrue(select_result["result"]['qReturn'],
-                        "Failed to select values")
-        self.qixe.clear_all_selections()
-
-    def test_select_excluded(self):
-        self.qixe.select_in_dimension('Alpha',
-                                      ['A', 'C', 'E'])
-        select_result = self.qixe.select_excluded_in_dimension('Alpha')
-        self.assertTrue(select_result['qReturn'],
-                        'Failed to select excluded')
-
-    def test_select_possible(self):
-        select_result = self.qixe.select_possible_in_dimension('Alpha')
-        self.assertTrue(select_result['qReturn'],
-                        'Failed to select possible')
-
-    def test_get_list_object_data(self):
-        self.assertTrue(len(self.qixe.get_list_object_data('Alpha')) == 26,
-                        'Failed to get value list')
-
-    def tearDown(self):
-        self.assertTrue(self.qixe.delete_app(self.opened_app),
-                        'Failed to delete app')
-
-
-if __name__ == '__main__':
-    unittest.main()