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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qe-api-client
-Version: 2.6.0
+Version: 2.8.0
 Summary: Python client for the Qlik Engine JSON API
 Home-page: https://github.com/lr-bicc/qe-api-client
 Author: Rumen Vasilev
@@ -11,8 +11,10 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: websocket-client>=0.47.0
+Requires-Dist: websocket-client>=1.0.0
 Requires-Dist: pandas>=2.2.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: uuid>=1.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{qe_api_client-2.6.0 → qe_api_client-2.8.0}/qe_api_client/api_classes/engine_generic_dimension_api.py

@@ -36,3 +36,22 @@ class EngineGenericDimensionApi:
             return response["result"]["qReturn"]
         except KeyError:
             return response["error"]
+
+    def apply_patches(self, handle: int, patches: list):
+        """
+        Applies a patch to the properties of an object. Allows an update to some of the properties.
+
+        Parameters:
+            handle (int): The handle identifying the generic object.
+            patches (list): List of patches.
+
+        Returns:
+            dict: Operation succeeded.
+        """
+        msg = json.dumps({"jsonrpc": "2.0", "id": 0, "handle": handle, "method": "ApplyPatches",
+                          "params": {"qPatches": patches}})
+        response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
+        try:
+            return response["result"]
+        except KeyError:
+            return response["error"]

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

@@ -208,3 +208,21 @@ class EngineGenericObjectApi:
             return response["result"]
         except KeyError:
             return response["error"]
+
+
+    def get_properties(self, handle: int):
+        """
+        Retrieves the properties of a specific generic object.
+
+        Parameters:
+            handle (int): The handle identifying the generic object.
+
+        Returns:
+            dict: The properties 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": "GetProperties", "params": {}})
+        response = json.loads(self.engine_socket.send_call(self.engine_socket, msg))
+        try:
+            return response["result"]["qProp"]
+        except KeyError:
+            return response["error"]

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

@@ -1,3 +1,5 @@
+import json
+
 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.api_classes.engine_field_api as engine_field_api
@@ -93,8 +95,14 @@ class QixEngine:
         fld_handle = self.get_handle(lb_field)
         return self.efa.clear(fld_handle)
 
+
     def create_single_master_dimension(self, app_handle: int, dim_title: str, dim_def: str, dim_label: str = "",
-                                       dim_desc: str = "", dim_tags: list = None):
+                                       dim_desc: str = "", dim_tags: list = None, dim_color: str = None,
+                                       dim_color_index: int = -1, value_colors: list = None,
+                                       null_value_color: str = None, null_value_color_index: int = -1,
+                                       other_value_color: str = None, other_value_color_index: int = -1,
+                                       single_color: str = None, single_color_index: int = -1, palette: str = None
+                                       ):
         """
         Creates a single master dimension.
 
@@ -105,28 +113,108 @@ class QixEngine:
             dim_label (str, optional): The label of the dimension.
             dim_desc (str, optional): The description of the dimension.
             dim_tags (list, optional): The tags of the dimension.
+            dim_color (str, optional): The master dimension color.
+            dim_color_index (int, optional): The index of the master dimension color in the theme color picker.
+            value_colors (list, optional): The value colors of the master dimension.
+            null_value_color (str, optional): The NULL value color of the master dimension.
+            null_value_color_index (int, optional): The index of the NULL value color of the master dimension in the theme color picker.
+            other_value_color (str, optional): The OTHER value color of the master dimension.
+            other_value_color_index (int, optional): The index of the OTHER value color of the master dimension in the theme color picker.
+            single_color (str, optional): Single color of the values of the master dimension.
+            single_color_index (int, optional): The index of single color of the values of the master dimension in the theme color picker.
+            palette (str, optional): Choose a color palette, if there are more than one.
 
         Returns:
             dict: The handle and Id of the dimension.
         """
+        if value_colors is None:
+            value_colors = []
         if dim_tags is None:
             dim_tags = []
 
         # Define of the single dimension properties
         nx_info = self.structs.nx_info(obj_type="dimension")
+        if dim_color is None:
+            coloring = self.structs.dim_coloring()
+        else:
+            coloring = self.structs.dim_coloring(base_color={"color": dim_color, "index": dim_color_index})
+
         nx_library_dimension_def = self.structs.nx_library_dimension_def(grouping="N", field_definitions=[dim_def],
                                                                          field_labels=[dim_title],
-                                                                         label_expression=dim_label)
+                                                                         label_expression=dim_label, alias=dim_title,
+                                                                         title=dim_title, coloring=coloring)
         gen_dim_props = self.structs.generic_dimension_properties(nx_info=nx_info,
                                                                   nx_library_dimension_def=nx_library_dimension_def,
                                                                   title=dim_title, description=dim_desc, tags=dim_tags)
 
         # Create the single dimension
         master_dim = self.eaa.create_dimension(app_handle, gen_dim_props)
+
+        # Get id and handle of the master dimension
+        master_dim_id = self.get_id(master_dim)
+        master_dim_handle = self.get_handle(master_dim)
+
+        # Update "colorMapRef" property with the master dimension id.
+        patch_value = json.dumps(master_dim_id)
+        patch_color_map_ref = self.structs.nx_patch(op="replace", path="/qDim/coloring/colorMapRef", value=patch_value)
+        self.egda.apply_patches(handle=master_dim_handle, patches=[patch_color_map_ref])
+
+        # Define the color properties
+        if null_value_color is None:
+            null_value = None
+        else:
+            null_value = {"color": null_value_color, "index": null_value_color_index}
+
+        if other_value_color is None:
+            other_value = None
+        else:
+            other_value = {"color": other_value_color, "index": other_value_color_index}
+
+        if single_color is None:
+            single = None
+        else:
+            single = {"color": single_color, "index": single_color_index}
+
+        colors = value_colors
+        color_map = self.structs.color_map(colors=colors, nul=null_value, oth=other_value, single=single, pal=palette)
+        color_map_props = self.structs.color_map_properties(dim_id=master_dim_id, _color_map=color_map)
+
+        # Create color map object, if colors are passed.
+        if value_colors or null_value_color is not None or other_value_color is not None or single_color is not None or palette is not None:
+            color_map_model = self.eaa.create_object(app_handle, color_map_props)
+            color_map_model_handle = self.get_handle(color_map_model)
+
+            # Set "autoFill" and "usePal" to "False", if a single color is passed.
+            if bool(single):
+                patch_value_use_pal_auto_fill = json.dumps(False)
+                patch_use_pal = self.structs.nx_patch(op="replace", path="/colorMap/usePal",
+                                                      value=patch_value_use_pal_auto_fill)
+                self.egda.apply_patches(handle=color_map_model_handle, patches=[patch_use_pal])
+
+                patch_auto_fill = self.structs.nx_patch(op="replace", path="/colorMap/autoFill",
+                                                      value=patch_value_use_pal_auto_fill)
+                self.egda.apply_patches(handle=color_map_model_handle, patches=[patch_auto_fill])
+
+            # Set "autoFill" to "False", if a color palette is passed.
+            if palette is not None:
+                patch_value_auto_fill = json.dumps(False)
+                patch_auto_fill = self.structs.nx_patch(op="replace", path="/colorMap/autoFill",
+                                                        value=patch_value_auto_fill)
+                self.egda.apply_patches(handle=color_map_model_handle, patches=[patch_auto_fill])
+
+        # Update "hasValueColors" property, if value colors are passed.
+        if value_colors:
+            patch_value_has_value_colors = json.dumps(True)
+            patch_has_value_colors = self.structs.nx_patch(op="replace", path="/qDim/coloring/hasValueColors",
+                                                        value=patch_value_has_value_colors)
+            self.egda.apply_patches(handle=master_dim_handle, patches=[patch_has_value_colors])
+
         return master_dim
 
+
     def create_master_measure(self, app_handle: int, mes_title: str, mes_def: str, mes_label: str = "",
-                              mes_desc: str = "", mes_tags: list = None):
+                              mes_desc: str = "", mes_tags: list = None, mes_color: str = None,
+                              mes_color_index: int = -1, gradient: dict = None):
         """
         Creates a master measure.
 
@@ -137,6 +225,8 @@ class QixEngine:
             mes_label (str, optional): The label of the measure.
             mes_desc (str, optional): The description of the measure.
             mes_tags (list, optional): The tags of the measure.
+            mes_color (str, optional): The color of the measure.
+            mes_color_index (int, optional): The index of the color of the measure.
 
         Returns:
             dict: The handle and Id of the measure.
@@ -146,8 +236,17 @@ class QixEngine:
 
         # Define of the measure properties
         nx_info = self.structs.nx_info(obj_type="measure")
+
+        if mes_color is None:
+            coloring = self.structs.mes_coloring()
+        else:
+            coloring = self.structs.mes_coloring(base_color={"color": mes_color, "index": mes_color_index})
+
+        if gradient is not None:
+            coloring.update({"gradient": gradient})
+
         nx_library_measure_def = self.structs.nx_library_measure_def(label=mes_title, mes_def=mes_def,
-                                                                     label_expression=mes_label)
+                                                                     label_expression=mes_label, coloring=coloring)
         gen_mes_props = self.structs.generic_measure_properties(nx_info=nx_info,
                                                                 nx_library_measure_def=nx_library_measure_def,
                                                                 title=mes_title, description=mes_desc, tags=mes_tags)
@@ -310,8 +409,12 @@ class QixEngine:
         nx_info = self.structs.nx_info(obj_type=obj_type)
         if obj_type == "table":
             chart_props = self.structs.table_properties(info=nx_info, hypercube_def=hypercube_def)
+        elif obj_type == "sn-table":
+            chart_props = self.structs.sn_table_properties(info=nx_info, hypercube_def=hypercube_def)
         elif obj_type == "pivot-table":
             chart_props = self.structs.pivot_table_properties(info=nx_info, hypercube_def=hypercube_def)
+        elif obj_type == "sn-pivot-table":
+            chart_props = self.structs.pivot_table_properties(info=nx_info, hypercube_def=hypercube_def)
         else:
             print("Not valid object type.")
 
@@ -435,14 +538,25 @@ class QixEngine:
         # 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']
+
+        if no_of_columns == 0:
+            return 'The chart either contains no columns or has a calculation condition!'
+
         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
+        dimension_info = obj_layout['qHyperCube'].get('qDimensionInfo', [])
+        measure_info = obj_layout['qHyperCube'].get('qMeasureInfo', [])
+        column_info = dimension_info + measure_info
+
+        # Build the column mapping using qEffectiveInterColumnSortOrder
+        sort_order = sorted(obj_layout['qHyperCube']['qEffectiveInterColumnSortOrder'])
+        sort_order_positive = [x for x in sort_order if x >= 0]
+        column_names = []
+        for i in sort_order_positive:
+            column_names.append(column_info[i]["qFallbackTitle"])
 
         # if the type of the charts has a straight data structure
         if (obj_layout['qInfo']['qType'] in ['table', 'sn-table', 'piechart', 'scatterplot', 'combochart', 'barchart']
@@ -472,9 +586,10 @@ class QixEngine:
 
             # 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']:
+                label = node.get('qText', '')  # Leerer String, falls nicht vorhanden
+                dimensions = [label]
+
+                if 'qSubNodes' in node and node['qSubNodes']:
                     sub_dimensions = []
                     for sub_node in node['qSubNodes']:
                         sub_dimensions.extend([dimensions + d for d in get_all_dimensions(sub_node)])
@@ -482,13 +597,25 @@ class QixEngine:
                 else:
                     return [dimensions]
 
-            # Gets the column headers for the pivot table
+            # Supporting function to get all column headers for the pivot table
+            def get_column_paths(node):
+                label = node.get('qText', '')
+                current_path = [label]
+
+                if 'qSubNodes' in node and node['qSubNodes']:
+                    paths = []
+                    for sub in node['qSubNodes']:
+                        for path in get_column_paths(sub):
+                            paths.append(current_path + path)
+                    return paths
+                else:
+                    return [current_path]
+
             col_headers = []
             nx_page_top = self.structs.nx_page(left=0, top=0, width=width, height=1)
-            hc_top = self.egoa.get_hypercube_pivot_data(obj_handle, '/qHyperCubeDef', nx_page_top)[
-                'qDataPages'][0]['qTop']
+            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))
+                col_headers.extend(get_column_paths(top_node))
 
             # Paging variables
             page = 0
@@ -519,6 +646,9 @@ class QixEngine:
 
             # Creates the Dataframe
             df = pd.DataFrame(data_values, index=row_index, columns=col_index)
+            index_levels = df.index.nlevels
+            df.index.names = column_names[:index_levels]
+            df = df.reset_index()
 
         # if the type of the charts has a stacked data structure
         elif obj_layout['qInfo']['qType'] in ['barchart'] and obj_layout['qHyperCube']['qStackedDataPages'] != []:

{qe_api_client-2.6.0 → qe_api_client-2.8.0}/qe_api_client/structs.py

@@ -263,26 +263,32 @@ def generic_dimension_properties(nx_info: dict, nx_library_dimension_def: dict,
 
 
 def nx_library_dimension_def(grouping: str = "N", field_definitions: list = None, field_labels: list = None,
-                             label_expression: str = ""):
+                             label_expression: str = "", alias: str = "", title: str = "", coloring: dict = None):
+    if coloring is None:
+        coloring = {}
     if field_labels is None:
         field_labels = []
     if field_definitions is None:
         field_definitions = []
     return {
         "qGrouping": grouping, "qFieldDefs": field_definitions, "qFieldLabels": field_labels,
-        "qLabelExpression": label_expression
+        "qLabelExpression": label_expression, "qAlias": alias, "title": title, "coloring": coloring
     }
 
 
 def nx_library_measure_def(label: str, mes_def: str, grouping: str = "N", expressions: list = None,
-                           active_expression: int = 0, label_expression:str = "", num_format: dict = None):
+                           active_expression: int = 0, label_expression:str = "", num_format: dict = None,
+                           coloring: dict = None):
+    if coloring is None:
+        coloring = {}
     if num_format is None:
         num_format = {}
     if expressions is None:
         expressions = []
     return {
         "qLabel": label, "qDef": mes_def,"qGrouping": grouping, "qExpressions": expressions,
-        "qActiveExpression": active_expression, "qLabelExpression": label_expression, "qNumFormat": num_format
+        "qActiveExpression": active_expression, "qLabelExpression": label_expression, "qNumFormat": num_format,
+        "coloring": coloring
     }
 
 
@@ -380,16 +386,18 @@ def nx_attr_expr_def(expression: str = "", library_id: str = "", attribute: bool
         "qLabelExpression": label_expression
     }
 
+
 def table_properties(
         info: dict, hypercube_def: dict, prop_def: dict = None, extends_id: str = "", state_name: str = "",
         script: str = "", _search: dict = None, show_titles: bool = True, title: str = "", subtitle: str = "",
         footnote: str = "", disable_nav_menu: bool = False, show_details: bool = False,
-        show_details_expression: bool = False, totals_show: bool = True, totals_position: str = "noTotals",
-        totals_label: str = "Totals", scrolling_horizontal: bool = True, scrolling_keep_first_column_in_view: bool = False,
+        show_details_expression: bool = False, _totals: dict = None, scrolling_horizontal: bool = True, scrolling_keep_first_column_in_view: bool = False,
         scrolling_keep_first_column_in_view_touch: bool = False, multiline_wrap_text_in_headers: bool = True,
         multiline_wrap_text_in_cells: bool = True
 ):
 
+    if _totals is None:
+        _totals = totals()
     if prop_def is None:
         prop_def = {}
     if _search is None:
@@ -399,14 +407,39 @@ def table_properties(
         "qInfo": info, "qExtendsId": extends_id, "qMetaDef": prop_def, "qStateName": state_name,
         "qHyperCubeDef": hypercube_def, "script": script, "search": _search, "showTitles": show_titles, "title": title,
         "subtitle": subtitle, "footnote": footnote, "disableNavMenu": disable_nav_menu, "showDetails": show_details,
-        "showDetailsExpression": show_details_expression,
-        "totals": {"show": totals_show, "position": totals_position, "label": totals_label},
+        "showDetailsExpression": show_details_expression, "totals": _totals,
         "scrolling": {"horizontal": scrolling_horizontal, "keepFirstColumnInView": scrolling_keep_first_column_in_view, "keepFirstColumnInViewTouch": scrolling_keep_first_column_in_view_touch},
         "multiline": {"wrapTextInHeaders": multiline_wrap_text_in_headers, "wrapTextInCells": multiline_wrap_text_in_cells},
         "visualization": "table"
     }
 
 
+def sn_table_properties(
+        info: dict, hypercube_def: dict, prop_def: dict = None, extends_id: str = "", state_name: str = "",
+        show_titles: bool = True, title: str = "", subtitle: str = "", footnote: str = "", disable_nav_menu: bool = False,
+        show_details: bool = False, show_details_expression: bool = False, components: list = None, _totals: dict = None,
+        use_pagination: bool = False, enable_chart_exploration: bool = False, chart_exploration: dict = None
+):
+
+    if chart_exploration is None:
+        chart_exploration = {"menuVisibility": "auto"}
+    if components is None:
+        components = []
+    if _totals is None:
+        _totals = totals()
+    if prop_def is None:
+        prop_def = {}
+
+    return {
+        "qInfo": info, "qExtendsId": extends_id, "qMetaDef": prop_def, "qStateName": state_name,
+        "qHyperCubeDef": hypercube_def, "showTitles": show_titles, "title": title, "subtitle": subtitle,
+        "footnote": footnote, "disableNavMenu": disable_nav_menu, "showDetails": show_details,
+        "showDetailsExpression": show_details_expression, "components": components, "totals": _totals,
+        "usePagination": use_pagination, "enableChartExploration": enable_chart_exploration,
+        "chartExploration": chart_exploration, "visualization": "sn-table"
+    }
+
+
 def pivot_table_properties(
         info: dict, hypercube_def: dict, prop_def: dict = None, extends_id: str = "", state_name: str = "",
         _search: dict = None, show_titles: bool = True, title: str = "", subtitle: str = "",
@@ -427,9 +460,109 @@ def pivot_table_properties(
     }
 
 
+def sn_pivot_table_properties(
+        info: dict, hypercube_def: dict, prop_def: dict = None, extends_id: str = "", state_name: str = "",
+        _search: dict = None, show_titles: bool = True, title: str = "", subtitle: str = "",
+        footnote: str = "", disable_nav_menu: bool = False, show_details: bool = True,
+        show_details_expression: bool = False, components: list = None, null_value_representation: dict = None
+):
+    if null_value_representation is None:
+        null_value_representation = {"text": "-"}
+    if components is None:
+        components = []
+    if prop_def is None:
+        prop_def = {}
+    if _search is None:
+        _search = search()
+
+    return {
+        "qInfo": info, "qExtendsId": extends_id, "qMetaDef": prop_def, "qStateName": state_name,
+        "qHyperCubeDef": hypercube_def, "search": _search, "showTitles": show_titles, "title": title,
+        "subtitle": subtitle, "footnote": footnote, "disableNavMenu": disable_nav_menu, "showDetails": show_details,
+        "showDetailsExpression": show_details_expression, "components": components,
+        "nullValueRepresentation": null_value_representation, "visualization": "sn-pivot-table"
+    }
+
+
 def search(sorting: str = "auto"):
     return {"sorting": sorting}
 
 
 def text_align(auto: bool = True, align: str = "left"):
-    return {"auto": auto, "align": align}
+    return {"auto": auto, "align": align}
+
+
+def totals(totals_show: bool = True, totals_position: str = "noTotals", totals_label: str = "Totals"):
+    return {"show": totals_show, "position": totals_position, "label": totals_label}
+
+
+def color_map(colors: list = None, nul: dict = None, oth: dict = None, pal: str = None, single: dict = None,
+              use_pal: bool = True, auto_fill: bool = True):
+
+    if colors is None:
+        colors = []
+
+    return {
+        "colors": colors,
+        "nul": nul,
+        "oth": oth,
+        "pal": pal,
+        "single": single,
+        "usePal": use_pal,
+        "autoFill": auto_fill
+    }
+
+
+def dim_coloring(change_hash: str = None, color_map_ref: str = "", has_value_colors: bool = False, base_color: dict = None):
+    if base_color is None:
+        base_color = {"color": "none", "index": 0}
+    return {
+        "changeHash": change_hash,
+        "colorMapRef": color_map_ref,
+        "hasValueColors": has_value_colors,
+        "baseColor": base_color
+    }
+
+
+def mes_coloring(base_color: dict = None, _gradient: dict = None):
+    coloring = {}
+    if base_color is not None:
+        coloring.update({"baseColor": base_color})
+    if _gradient is not None:
+        coloring.update({"gradient": _gradient})
+    return coloring
+
+
+def color_map_properties(dim_id: str, prop_def:dict = None, extends_id: str = "", state_name: str = "",
+                         _color_map: dict = None):
+
+    if _color_map is None:
+        _color_map = color_map()
+    if prop_def is None:
+        prop_def = {}
+    info = nx_info(obj_type="ColorMap", obj_id="ColorMapModel_" + dim_id)
+
+    return {
+        "qInfo": info, "qExtendsId": extends_id, "qMetaDef": prop_def, "qStateName": state_name, "colorMap": _color_map
+    }
+
+
+def value_color(value: str, color: str, index: int = -1):
+    return {
+        "value": value,
+        "baseColor": {"color": color, "index": index}
+    }
+
+
+def color(_color: str, index: int = -1):
+    return {"color": _color, "index": index}
+
+
+def gradient(colors: list = None, break_types: list = None, limits: list = None, limit_type: str = "percent"):
+    if colors is None:
+        colors = [color(_color="#332288"), color(_color="#117733")]
+    if break_types is None:
+        break_types = [False]
+    if limits is None:
+        limits = [0.5]
+    return {"colors": colors, "breakTypes": break_types, "limits": limits, "limitType": limit_type}

{qe_api_client-2.6.0 → qe_api_client-2.8.0}/qe_api_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qe-api-client
-Version: 2.6.0
+Version: 2.8.0
 Summary: Python client for the Qlik Engine JSON API
 Home-page: https://github.com/lr-bicc/qe-api-client
 Author: Rumen Vasilev
@@ -11,8 +11,10 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: websocket-client>=0.47.0
+Requires-Dist: websocket-client>=1.0.0
 Requires-Dist: pandas>=2.2.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: uuid>=1.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

qe_api_client-2.8.0/qe_api_client.egg-info/requires.txt

@@ -0,0 +1,4 @@
+websocket-client>=1.0.0
+pandas>=2.2.0
+numpy>=2.0.0
+uuid>=1.0

{qe_api_client-2.6.0 → qe_api_client-2.8.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="qe-api-client",
-    version="2.6.0",
+    version="2.8.0",
     author="Rumen Vasilev",
     author_email="R.Vasilev@LRWorld.com",
     description="Python client for the Qlik Engine JSON API",
@@ -20,8 +20,10 @@ setuptools.setup(
         "Operating System :: OS Independent",
     ],
     install_requires=[
-        'websocket-client>=0.47.0',
-        'pandas>=2.2.0'
+        'websocket-client>=1.0.0',
+        'pandas>=2.2.0',
+        'numpy>=2.0.0',
+        'uuid>=1.0'
     ],
     python_requires='>=3.6',
 )

qe_api_client-2.8.0/test/test.py

@@ -0,0 +1,36 @@
+from qe_api_client.engine import QixEngine
+import math
+import pandas as pd
+
+url = 'ws://localhost:4848/app'
+qixe = QixEngine(url=url)
+
+# url = "lr-analytics-test.lr-netz.local"
+# user_directory = "LR"
+# user_id = "!QlikSense"
+# qlik_certs_path = "C:/LocalUserData/Certificates/Sense TEST"
+# ca_certs = qlik_certs_path + "/root.pem"
+# certfile = qlik_certs_path + "/client.pem"
+# keyfile = qlik_certs_path + "/client_key.pem"
+# qixe = QixEngine(url, user_directory, user_id, ca_certs, certfile, keyfile)
+
+# App ID holen
+# app_id = "0c6a91a3-4dc0-490e-ae0f-41391b39c2ec" # Bonus Competitions
+# app_id = "f9e79d92-652b-4ba8-8487-84e2825b71c5"     # Sales KPI
+# app_id = "3b9ef434-f4e9-4310-9cef-1347502bc39d"     # Stocks
+# app_id = "0a64346c-da25-4fd5-b1a7-e3d897d270e3"     # Sales & Stocks
+app_id = "Test.qvf"
+
+# App öffnen
+opened_app = qixe.ega.open_doc(app_id)
+
+app_handle = qixe.get_handle(opened_app)
+
+# qixe.select_in_field(app_handle=app_handle, field_name="TopicBox_ABC_Analysis", list_of_values=["ABC Analysis", "Detailed stock information", "Avg. sales per week + range of coverage", "Sales per month", "Sales per week"])
+
+df = qixe.get_chart_data(app_handle=app_handle, obj_id="xPpxvy")
+print(df.to_string())
+df.to_csv('C:/Users/R.Vasilev/OneDrive - LR/Desktop/out.csv', index=False)
+
+# Websocket-Verbindung schließen
+QixEngine.disconnect(qixe)

qe_api_client-2.6.0/qe_api_client.egg-info/requires.txt

@@ -1,2 +0,0 @@
-websocket-client>=0.47.0
-pandas>=2.2.0

qe_api_client-2.6.0/test/test.py

@@ -1,43 +0,0 @@
-from qe_api_client.engine import QixEngine
-import math
-import pandas as pd
-
-# url = 'ws://localhost:4848/app'
-# qixe = QixEngine(url=url)
-
-url = "lr-analytics-test.lr-netz.local"
-user_directory = "LR"
-user_id = "!QlikSense"
-qlik_certs_path = "C:/LocalUserData/Certificates/Sense TEST"
-ca_certs = qlik_certs_path + "/root.pem"
-certfile = qlik_certs_path + "/client.pem"
-keyfile = qlik_certs_path + "/client_key.pem"
-qixe = QixEngine(url, user_directory, user_id, ca_certs, certfile, keyfile)
-
-# App ID holen
-doc_id = "0c6a91a3-4dc0-490e-ae0f-41391b39c2ec" # Bonus Competitions
-# doc_id = "f9e79d92-652b-4ba8-8487-84e2825b71c5"     # Sales KPI
-# doc_id = "Test.qvf"
-
-# App öffnen
-opened_doc = qixe.ega.open_doc(doc_id)
-print(opened_doc)
-
-doc_handle = qixe.get_handle(opened_doc)
-
-# # Lineage-Daten aus der API holen
-# lineage = qixe.eaa.get_lineage(doc_handle)
-# print(lineage)
-#
-# # Erstelle den DataFrame und fülle fehlende Werte mit ""
-# df = pd.DataFrame(lineage)  #.fillna("")
-# df = df[(df["qDiscriminator"].notna()) | (df["qStatement"].notna())].fillna("")
-# # df = df.reindex(columns=["qDiscriminator", "qStatement"]).fillna("")
-
-df = qixe.get_app_lineage_info(doc_handle)
-
-print(df)
-
-
-# Websocket-Verbindung schließen
-QixEngine.disconnect(qixe)