minor cleanups while I try to get query_progress over the line

Author: nickzoic

countess/core/pipeline.py

@@ -173,9 +173,10 @@ def poll_percent(self):
         if self.status == PipelineNodeStatus.DONE:
             return 100
         elif self.status == PipelineNodeStatus.WORK:
-            return self.plugin.query_progress(self.cursor)
+            qp = self.plugin.query_progress(self.cursor)
+            return qp if qp > 0 else 0
         else:
-            return 0
+            return -1
 
     def run(self, ddbc, row_limit: Optional[int] = None):
         if not self.plugin:

countess/gui/main.py

@@ -252,24 +252,28 @@ def config_change_callback(self, *_):
     def config_change_task_callback(self):
         """Called when the user makes a change and had paused for a bit"""
         self.config_change_task = None
-        logger.debug("config_change_task_callback")
-
         self.node.stop()
+        self.config_change_start()
+
+    def choose_plugin(self, plugin_class):
+        self.node.plugin = plugin_class()
+        self.config_change_start()
+
+    def config_change_start(self):
+        self.node.is_dirty = True
         self.node.start(self.ddbc, preview_row_limit)
         self.config_change_poll_callback()
 
     def config_change_poll_callback(self):
         percent = self.node.poll_percent()
         if percent < 0:
             logger.info("%s: 0/0", self.node.name)
-        elif percent < 100:
+        elif 0 <= percent < 100:
             logger.info("%s: %d%%", self.node.name, percent)
-        else:
+            self.frame.after(50, self.config_change_poll_callback)
+        elif percent == 100:
             logger.info("%s: 100%%", self.node.name)
             self.config_change_poll_done()
-            return
-
-        self.frame.after(50, self.config_change_poll_callback)
 
     def config_change_poll_done(self):
         self.node.wait()
@@ -285,14 +289,6 @@ def config_change_poll_done(self):
         self.config_canvas.yview_moveto(pos1)
         self.config_scrollbar.set(pos1, pos2)
 
-    def choose_plugin(self, plugin_class):
-        self.node.plugin = plugin_class()
-        # self.node.prerun()
-        self.node.is_dirty = True
-        self.node.run(self.ddbc, preview_row_limit)
-        self.show_config_subframe()
-        self.change_callback(self.node)
-
     def destroy(self):
         if self.config_change_task:
             self.frame.after_cancel(self.config_change_task)
@@ -302,13 +298,13 @@ def destroy(self):
 class SplashWrapper:
     def __init__(self, tk_parent):
         self.frame = tk.Frame(tk_parent)
-        self.frame.configure(cursor = 'heart')
+        self.frame.configure(cursor="heart")
 
         font = ("TkHeadingFont", 16, "bold")
-        subframe = tk.Frame(self.frame, highlightbackground='black', highlightthickness=1)
-        subframe.grid(padx=10,pady=10)
-        self.frame.columnconfigure(0,weight=1)
-        self.frame.rowconfigure(0,weight=1)
+        subframe = tk.Frame(self.frame, highlightbackground="black", highlightthickness=1)
+        subframe.grid(padx=10, pady=10)
+        self.frame.columnconfigure(0, weight=1)
+        self.frame.rowconfigure(0, weight=1)
         tk.Label(subframe, image=get_icon(tk_parent, "countess")).grid(padx=10, pady=10)
         tk.Label(subframe, text=f"CountESS {VERSION}", font=font).grid(padx=10, pady=10)
 

countess/gui/tabular.py

@@ -1,6 +1,5 @@
 import io
 import logging
-import threading
 import tkinter as tk
 from functools import partial
 from math import ceil, floor, isinf, isnan
@@ -15,7 +14,6 @@
     duckdb_dtype_is_numeric,
     duckdb_dtype_to_datatype_choice,
     duckdb_escape_identifier,
-    duckdb_escape_literal,
 )
 
 logger = logging.getLogger(__name__)
@@ -239,71 +237,37 @@ def set_sort_order(self, column_num: int, descending: Optional[bool] = None):
             self.sort_ascending = not descending
         self.sort_by_col = column_num
 
-        # Include all column names for a stable sort order.
+        # Create an index for whatever column we're sorting by, followed by
+        # all other column names for a stable sort order.
+
         column_name = self.table.columns[column_num]
         escaped_column_names = [
             duckdb_escape_identifier(c) for c in [column_name] + [c for c in self.table.columns if c != column_name]
         ]
 
-        # We add an index for whatever column we're sorting by,
-        # if it doesn't already exist.
-        # XXX could do this in a thread?
-        index_name = f"{self.table.alias}__{column_name}__idx"
-        index_identifier = duckdb_escape_identifier(index_name)
-        index_literal = duckdb_escape_literal(index_name)
+        index_identifier = f"{self.table.alias}_{column_num}_idx"
 
-        def _create_index_continue():
-            direction = "ASC" if self.sort_ascending else "DESC"
-            self.table_order = ",".join(f"{c} {direction}" for c in escaped_column_names)
+        # XXX I did have some code here which built the index in a separate thread / cursor but it
+        # was mad with race conditions so I've scrapped it for now and the GUI will just have to
+        # awkwardly pause.
 
-            logger.debug("TabularDataFrame set_sort_order %s %s", column_name, self.table_order)
+        sql = (
+            f"CREATE INDEX IF NOT EXISTS {index_identifier} ON {self.table.alias} ("
+            + ",".join(escaped_column_names)
+            + ")"
+        )
+        self.ddbc.sql(sql)
 
-            for n, label in enumerate(self.labels):
-                icon = "sort_un" if n != column_num else "sort_up" if self.sort_ascending else "sort_dn"
-                label.configure(image=get_icon(self, icon))
+        direction = "ASC" if self.sort_ascending else "DESC"
+        self.table_order = ",".join(f"{c} {direction}" for c in escaped_column_names)
 
-            self.refresh()
+        logger.debug("TabularDataFrame set_sort_order %s %s", column_name, self.table_order)
 
-        # XXX workaround for https://github.com/duckdb/duckdb/issues/16086
-        if not self.ddbc.sql(f"select 1 from duckdb_indexes() where index_name = {index_literal}"):
-            cursor = self.ddbc.cursor()
-            cursor.sql("set enable_progress_bar_print=false")
-            cursor.sql("set progress_bar_time=0")
-
-            if self._set_sort_order_thread and self._set_sort_order_thread.is_alive():
-                logger.debug("TabularDataFrame set_sort_order thread already running")
-                self._set_sort_order_thread.join()
-
-            def _create_index_thread():
-                sql = (
-                    f"CREATE INDEX IF NOT EXISTS {index_identifier} ON {self.table.alias} ("
-                    + ",".join(escaped_column_names)
-                    + ")"
-                )
-                logger.debug("TabularDataFrame set_sort_order index sql %s", sql)
-                cursor.sql(sql)
-
-            self._set_sort_order_thread = threading.Thread(target=_create_index_thread)
-            self._set_sort_order_thread.start()
-
-            def _create_index_monitor():
-                if self._set_sort_order_thread.is_alive():
-                    try:
-                        qp = cursor.query_progress()
-                    except AttributeError:
-                        qp = 50
-
-                    if qp >= 0:
-                        logger.info("Indexing: %d%%", qp)
-                    self.after(50, _create_index_monitor)
-                else:
-                    self._set_sort_order_thread.join()
-                    logger.info("Indexing: 100%")
-                    _create_index_continue()
-
-            self.after(50, _create_index_monitor)
-        else:
-            _create_index_continue()
+        for n, label in enumerate(self.labels):
+            icon = "sort_un" if n != column_num else "sort_up" if self.sort_ascending else "sort_dn"
+            label.configure(image=get_icon(self, icon))
+
+        self.refresh()
 
     def _label_button_1(self, num, event):
         """Click on column labels to set sort order"""

countess/plugins/variant.py

@@ -203,7 +203,7 @@ def sql(self, table_name: str, columns: Iterable[str]) -> Optional[str]:
         prefix_aa = duckdb_escape_literal((self.prefix_aa.value + ":" if self.prefix_aa else "") + "p.")
         prefix_nt = duckdb_escape_literal((self.prefix_nt.value + ":" if self.prefix_nt else "") + "c.")
 
-        columns = ' '.join(duckdb_escape_identifier(c) + "," for c in columns if c != self.variant_out.value)
+        columns = " ".join(duckdb_escape_identifier(c) + "," for c in columns if c != self.variant_out.value)
 
         # XXX handle other short forms like _synNNNX>Y or whatever
         return rf"""