q2rad 0.1.207__tar.gz → 0.1.209__tar.gz

{q2rad-0.1.207 → q2rad-0.1.209}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q2rad
-Version: 0.1.207
+Version: 0.1.209
 Summary: RAD - database, GUI, reports
 Author: Andrei Puchko
 Author-email: andrei.puchko@gmx.de

{q2rad-0.1.207 → q2rad-0.1.209}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "q2rad"
-version = "0.1.207"
+version = "0.1.209"
 description = "RAD - database, GUI, reports"
 authors = ["Andrei Puchko <andrei.puchko@gmx.de>"]
 readme = "README.md"

{q2rad-0.1.207 → q2rad-0.1.209}/q2rad/q2appmanager.py

@@ -40,6 +40,7 @@ app_tables = [
 class AppManager(Q2Form):
     def __init__(self, title=""):
         super().__init__("Manage q2Application")
+        self.selected_tables = []
 
     def on_init(self):
         app_data = q2app.q2_app.selected_application
@@ -332,7 +333,68 @@ class AppManager(Q2Form):
                 rez[x].append(row)
         return rez
 
+    def tables_selector(self, mode="export"):
+        st = Q2Form(f"Select tables for {mode}")
+        st.ok_button = 1
+        st.cancel_button = 1
+
+        def get_widgets(st=st):
+            return [x for x in st.widgets() if x.startswith("c_")]
+
+        tables = [
+            x
+            for x in q2app.q2_app.db_data.get_tables()
+            if not x.startswith("log_") and x != "sqlite_sequence"
+        ]
+        if st.add_control("/v"):
+            if st.add_control("/vr"):
+                tables.sort()
+                for index, table in enumerate(tables):
+                    if self.selected_tables == []:
+                        check_data = 1
+                    else:
+                        check_data = table in self.selected_tables
+
+                    label = get("forms", f"form_table='{table}'", "title", self.q2_app.db_logic)
+                    st.add_control(
+                        f"c_{index}", pic=f"{table} ({label})", control="check", data=check_data, stretch=99
+                    )
+            st.add_control("/")
+        st.add_control("/")
+        st.add_control("/h")
+        st.add_control(
+            "all",
+            "Check all",
+            control="button",
+            datalen=10,
+            valid=lambda: [st.s.__setattr__(x, 1) for x in get_widgets()],
+        )
+        st.add_control(
+            "nothing",
+            "Uncheck all",
+            control="button",
+            datalen=10,
+            valid=lambda: [st.s.__setattr__(x, 0) for x in get_widgets()],
+        )
+        st.add_control(
+            "invert",
+            "Invert",
+            control="button",
+            datalen=10,
+            valid=lambda: [st.s.__setattr__(x, 0 if st.s.__getattr__(x) else 1) for x in get_widgets()],
+        )
+        st.add_control("/")
+        st.run()
+
+        if st.ok_pressed:
+            self.selected_tables = [
+                table for index, table in enumerate(tables) if st.s.__getattr__(f"c_{index}")
+            ]
+            return True
+
     def export_data(self, file=""):
+        if not self.tables_selector("export"):
+            return
         filetype = "JSON(*.json)"
         if not file:
             file, filetype = q2app.q2_app.get_save_file_dialoq("Export Database", filter=filetype)
@@ -349,14 +411,16 @@ class AppManager(Q2Form):
     def get_data_json(self):
         db: Q2Db = q2app.q2_app.db_data
         rez = {}
-        for x in db.get_tables():
-            if x in app_tables:
+        for table in db.get_tables():
+            if table in app_tables:
                 continue
-            if x.startswith("log_") or x == "sqlite_sequence":
+            if table.startswith("log_") or table == "sqlite_sequence":
                 continue
-            rez[x] = []
-            for row in db.table(x).records():
-                rez[x].append(row)
+            if table not in self.selected_tables:
+                continue
+            rez[table] = []
+            for row in db.table(table).records():
+                rez[table].append(row)
         return rez
 
     def import_q2market(self):
@@ -410,6 +474,8 @@ class AppManager(Q2Form):
             q2Mess("<br>".join(errors))
 
     def import_data(self, file=""):
+        if not self.tables_selector("import"):
+            return
         filetype = "JSON(*.json)"
         if not file:
             file, filetype = q2app.q2_app.get_open_file_dialoq("Import Data", filter=filetype)
@@ -418,10 +484,10 @@ class AppManager(Q2Form):
             return
 
         data = json.load(open(file))
-        self.import_json_data(data)
+        self.import_json_data(data, self.selected_tables)
 
     @staticmethod
-    def import_json_data(data):
+    def import_json_data(data, selected_tables=[]):
         db: Q2Db = q2app.q2_app.db_data
         db_tables = db.get_tables()
         wait_table = Q2WaitShow(len(data))
@@ -430,6 +496,8 @@ class AppManager(Q2Form):
             wait_table.step(table)
             if table not in db_tables:
                 continue
+            if selected_tables and table not in selected_tables:
+                continue
             wait_row = Q2WaitShow(len(data[table]))
             db.cursor(f"delete from {table}")
             for row in data[table]:

{q2rad-0.1.207 → q2rad-0.1.209}/q2rad/q2forms.py

@@ -262,7 +262,7 @@ class Q2Forms(Q2Form, Q2_save_and_run):
     def select_data_storage_table(self):
         choice = choice_table()
         if choice:
-            self.s.form_table = choice['table']
+            self.s.form_table = choice["table"]
             if self.s.name == "":
                 self.s.name = self.s.form_table
             if self.s.title == "":
@@ -272,7 +272,7 @@ class Q2Forms(Q2Form, Q2_save_and_run):
         choice = choice_column(self.s.form_table)
         if choice:
             self.s.form_table_sort += ", " if self.s.form_table_sort else ""
-            self.s.form_table_sort += choice['col']
+            self.s.form_table_sort += choice["col"]
 
     def form_runner(self):
         name = self.r.name
@@ -283,3 +283,29 @@ class Q2Forms(Q2Form, Q2_save_and_run):
             q2mess(_("Give me some NAME!!!"))
             self.w.name.set_focus()
             return False
+
+    def after_crud_save(self):
+        super().after_crud_save()
+        if self.crud_mode != "EDIT":
+            if self.s.form_table:
+                self.db.insert(
+                    "lines",
+                    {
+                        "name": self.s.name,
+                        "column": "id",
+                        "noform": "*",
+                        "nogrid": "*",
+                        "datatype": "int",
+                        "migrate": "*",
+                        "pk": "*",
+                        "ai": "*",
+                    },
+                )
+                self.db.insert(
+                    "actions",
+                    {
+                        "name": self.s.name,
+                        "action_mode": "1",
+                    },
+                )
+                self.refresh()

{q2rad-0.1.207 → q2rad-0.1.209}/q2rad/q2lines.py

@@ -22,7 +22,7 @@ from q2rad.q2raddb import last_error
 from q2rad.q2utils import Q2Form, int_
 
 from q2gui import q2app
-
+import csv
 
 import gettext
 
@@ -91,7 +91,8 @@ class Q2Lines(Q2Form, Q2_save_and_run):
         # self.add_seq_actions()
 
         self.add_action("Run", self.form_runner, hotkey="F4")
-        self.add_action("Fill", self.filler)
+        self.add_action("Fill from DB", self.filler)
+        self.add_action("Fill from CSV", self.csv_filler)
         self.add_action("-")
         self.add_action("Select panel", icon="⭥", worker=self.select_panel, hotkey="F3")
         self.add_action("Copy to", icon="❖", worker=self.copy_to)
@@ -103,6 +104,7 @@ class Q2Lines(Q2Form, Q2_save_and_run):
 
     def create_form(self):
         from q2rad.q2forms import Q2Forms
+
         self.add_control("id", "", datatype="int", pk="*", ai="*", noform=1, nogrid=1)
         self.add_control("column", _("Column name"), datalen=50)
         self.add_control("/")
@@ -188,7 +190,7 @@ class Q2Lines(Q2Form, Q2_save_and_run):
                         _("?"),
                         mess=_("Open list of existing tables"),
                         control="button",
-                        datalen=2,
+                        datalen=3,
                         valid=self.select_linked_table,
                     )
                     self.add_control("to_table", gridlabel=_("To table"), datatype="char", datalen=100)
@@ -199,7 +201,7 @@ class Q2Lines(Q2Form, Q2_save_and_run):
                         _("?"),
                         mess=_("Open list of existing tables"),
                         control="button",
-                        datalen=2,
+                        datalen=3,
                         valid=self.select_linked_table_pk,
                     )
                     self.add_control("to_column", gridlabel=_("To field"), datatype="char", datalen=100)
@@ -211,7 +213,7 @@ class Q2Lines(Q2Form, Q2_save_and_run):
                         _("?"),
                         mess=_("Open list of existing columns"),
                         control="button",
-                        datalen=2,
+                        datalen=3,
                         valid=self.select_linked_table_column,
                     )
                     self.add_control("/")
@@ -225,7 +227,7 @@ class Q2Lines(Q2Form, Q2_save_and_run):
                         _("?"),
                         mess=_("Open list of existing forms"),
                         control="button",
-                        datalen=2,
+                        datalen=3,
                         valid=self.select_linked_form,
                     )
                     self.add_control("to_form", gridlabel=_("Form to open"), datatype="char", datalen=100)
@@ -303,15 +305,7 @@ class Q2Lines(Q2Form, Q2_save_and_run):
         rows = self.get_grid_selected_rows()
         choice = choice_form()
         if choice:
-            seq = (
-                int_(
-                    q2cursor(
-                        f"select max(seq) as maxseq from lines where name='{choice['name']}'",
-                        q2app.q2_app.db_logic,
-                    ).r.maxseq
-                )
-                + 1
-            )
+            seq = self.get_next_sequence(choice["name"])
             for x in rows:
                 rec = self.model.get_record(x)
                 rec["seq"] = seq
@@ -321,6 +315,18 @@ class Q2Lines(Q2Form, Q2_save_and_run):
                     print(last_error(q2app.q2_app.db_logic))
             self.refresh()
 
+    def get_next_sequence(self, form_name):
+        seq = (
+            int_(
+                q2cursor(
+                    f"select max(seq) as maxseq from lines where name='{form_name}'",
+                    q2app.q2_app.db_logic,
+                ).r.maxseq
+            )
+            + 1
+        )
+        return seq
+
     def add_layout(self, layout_type):
         selected_row = sorted(self.get_grid_selected_rows())
         if len(selected_row) == 0:
@@ -401,8 +407,9 @@ class Q2Lines(Q2Form, Q2_save_and_run):
                 return
 
         cols = self.q2_app.db_data.db_schema.get_schema_columns(self.prev_form.r.form_table)
+        seq = self.get_next_sequence(self.prev_form.r.name)
         for x in cols:
-            if self.db.get("lines", f"name = '{self.prev_form.r.name}' and column = '{x}'") == {}:
+            if self.db.get("lines", f"name = '{self.prev_form.r.name}' and `column` = '{x}'") == {}:
                 insert(
                     "lines",
                     {
@@ -414,9 +421,46 @@ class Q2Lines(Q2Form, Q2_save_and_run):
                         "pk": cols[x]["pk"],
                         "ai": cols[x]["ai"],
                         "migrate": "*",
+                        "seq": seq,
+                    },
+                    self.db,
+                )
+                seq += 1
+        self.refresh()
+
+    def csv_filler(self):
+        if self.model.row_count() > 0:
+            if q2AskYN("Lines list is not empty! Are you sure") != 2:
+                return
+
+        csv_file_name = q2app.q2_app.get_open_file_dialoq("Open CSV file", filter="CSV (*.csv)")[0]
+        if not csv_file_name:
+            return
+
+        with open(csv_file_name) as csv_file:
+            reader = csv.DictReader(csv_file, dialect="excel", delimiter=";")
+            cols = {x: 0 for x in reader.fieldnames}
+            for x in reader:
+                for key, value in x.items():
+                    cols[key] = max(cols[key], len(value))
+            cols
+        seq = self.get_next_sequence(self.prev_form.r.name)
+        for x in cols:
+            if self.db.get("lines", f"name = '{self.prev_form.r.name}' and `column` = '{x}'") == {}:
+                insert(
+                    "lines",
+                    {
+                        "name": self.prev_form.r.name,
+                        "column": x,
+                        "label": x,
+                        "datatype": "char",
+                        "datalen": cols[x],
+                        "migrate": "*",
+                        "seq": seq,
                     },
                     self.db,
                 )
+                seq += 1
         self.refresh()
 
     def before_crud_save(self):
@@ -431,7 +475,6 @@ class Q2Lines(Q2Form, Q2_save_and_run):
         self.datatype_valid()
         self.control_valid()
         self.database_valid()
-        # self.next_sequense()
 
     def datatype_valid(self):
         self.w.datalen.set_enabled(self.s.datatype in ";".join(HAS_DATALEN))

{q2rad-0.1.207 → q2rad-0.1.209}/q2rad/q2packages.py

@@ -31,7 +31,7 @@ class Q2Packages(Q2Form):
 
     def on_init(self):
         self.add_control("package_name", _("Name"), datatype="char", datalen=100, pk="*")
-        self.add_control("package_alias", _("Alias"), datatype="char", datalen=100)
+        self.add_control("package_pipname", _("Pip name"), datatype="char", datalen=100)
         self.add_control("package_version", _("Version"), datatype="char", datalen=10)
         self.add_control("comment", _("Comment"), datatype="text")
 
@@ -53,17 +53,21 @@ class Q2Packages(Q2Form):
 
     def uninstall(self):
         if q2AskYN(f"You are about tu uninstall package: {self.r.package_name}") == 2:
-            self.q2_app.pip_uninstall(self.r.package_name)
+            self.q2_app.pip_uninstall(
+                self.r.package_name if self.r.package_pipname == "" else self.r.package_pipname
+            )
 
     def install(self):
         version = (
             self.r.package_version
             if self.r.package_version
-            else self.q2_app.get_package_versions(self.r.package_name)[0]
+            else self.q2_app.get_package_versions(self.r.package_name, self.r.package_pipname)[0]
         )
         if version:
             try:
-                self.q2_app.pip_install(self.r.package_name, version)
+                self.q2_app.pip_install(
+                    self.r.package_name if self.r.package_pipname == "" else self.r.package_pipname, version
+                )
             except Exception:
                 q2Mess(_(f"pip install <b>{self.r.package_name}</b> error!"))
             finally:
@@ -72,7 +76,9 @@ class Q2Packages(Q2Form):
             q2Mess(f"Package <b>{self.r.package_name}</b> not found!")
 
     def info(self):
-        latest_version, current_version = self.q2_app.get_package_versions(self.r.package_name)
+        latest_version, current_version = self.q2_app.get_package_versions(
+            self.r.package_name, self.r.package_pipname
+        )
         # if not current_version:
         #     current_version = "Was not imported; "
         #     _cv = self.q2_app.code_runner(

{q2rad-0.1.207 → q2rad-0.1.209}/q2rad/q2rad.py

@@ -60,7 +60,7 @@ from q2rad.q2packages import Q2Packages
 from q2rad.q2constants import Q2Constants, q2const
 from q2rad.q2queries import Q2Queries
 from q2rad.q2reports import Q2Reports, Q2RadReport
-from q2rad.q2utils import Q2Tasker, Q2Form, auto_filter, set_logging, open_folder  # noqa F401
+from q2rad.q2utils import Q2Tasker, Q2Form, auto_filter, set_logging, open_folder, open_document  # noqa F401
 from q2rad.q2utils import q2choice
 from q2rad.q2make import make_binary
 
@@ -110,7 +110,7 @@ def run_form(form_name, order="", where=""):
     return q2app.q2_app.run_form(form_name, order=order, where=where)
 
 
-def run_module(module_name=None, globals=globals(), locals=locals(), script="", import_only=False):
+def run_module(module_name=None, _globals={}, _locals=locals(), script="", import_only=False):
     if module_name is not None:
         script = q2app.q2_app.db_logic.get("modules", f"name = '{module_name}'", "script")
     if not script:
@@ -130,7 +130,7 @@ def run_module(module_name=None, globals=globals(), locals=locals(), script="",
         else:
             __name__ = "__main__"
 
-        locals.update(
+        _locals.update(
             {
                 "RETURN": None,
                 "ReturnEvent": ReturnEvent,
@@ -140,13 +140,15 @@ def run_module(module_name=None, globals=globals(), locals=locals(), script="",
                 "__name__": __name__,
             }
         )
+        _globals.update(globals())
+        _globals.update(_locals)
         try:
-            exec(code["code"], globals, locals)
+            exec(code["code"], _globals)
         except ReturnEvent as error:
             pass
         except Exception as error:
             explain_error()
-        return locals["RETURN"]
+        return _globals["RETURN"]
 
 
 def explain_error(tb=None, errtype=None):
@@ -193,8 +195,10 @@ def explain_error(tb=None, errtype=None):
     for x in error["locals"]:
         if x in ("RETURN", "ReturnEvent", "mem", "self", "q2_app", "form", "myapp", "__name__"):
             continue
+        # if x in globals():
+        #     continue
         value = str(error["locals"][x])[:100]
-        msg.append(f"{x}:{value}")
+        msg.append(f"{x}: {value}")
     msg.append("-" * 25)
     msg = "\n".join(msg)
 
@@ -519,11 +523,11 @@ class Q2RadApp(Q2App):
         # self.dev_mode = False
 
         if self.dev_mode:
-            self.add_menu("Dev|Forms", self.run_forms, toolbar=self.dev_mode)
-            self.add_menu("Dev|Modules", self.run_modules, toolbar=self.dev_mode)
-            self.add_menu("Dev|Querys", self.run_queries, toolbar=self.dev_mode)
-            self.add_menu("Dev|Reports", self.run_reports, toolbar=self.dev_mode)
-            self.add_menu("Dev|Packages", self.run_packages, toolbar=self.dev_mode)
+            self.add_menu("Dev|Forms", self.run_forms)
+            self.add_menu("Dev|Modules", self.run_modules)
+            self.add_menu("Dev|Querys", self.run_queries)
+            self.add_menu("Dev|Reports", self.run_reports)
+            self.add_menu("Dev|Packages", self.run_packages)
             if not self.frozen:
                 self.add_menu("Dev|-")
                 self.add_menu("Dev|Make binary", self.make_binary)
@@ -695,8 +699,13 @@ class Q2RadApp(Q2App):
             + f"&&{pip_command} pip install --upgrade --force-reinstall q2rad",
         )
 
-    def get_package_versions(self, package):
-        response = open_url(f"https://pypi.python.org/pypi/{package}/json")  # noqa F405
+    def get_package_versions(self, package, pipname=None):
+        if not isinstance(package, str):
+            pipname = package[1]
+            package = package[0]
+        response = open_url(
+            f"https://pypi.python.org/pypi/{pipname if pipname else package}/json"
+        )  # noqa F405
         if response:
             latest_version = json.load(response)["info"]["version"]
         else:
@@ -716,7 +725,7 @@ class Q2RadApp(Q2App):
                 except Exception as error:
                     _logger.error(f"Error checking version of {package}: {error}")
             if current_version is None:
-                q2mess(f"Error checkin curent version of {package}!")
+                q2mess(f"Error checking curent version of {package}!")
         else:
             current_version = None
 
@@ -731,8 +740,14 @@ class Q2RadApp(Q2App):
             if w.step(package):
                 break
             latest_version, current_version = self.get_package_versions(package)
+            # q2mess([package, latest_version, current_version])
             if self.db_logic is not None and package not in q2_modules:
-                pkg_ver = get("packages", f"package_name='{package}'", "package_version", q2_db=self.db_logic)
+                pkg_ver = get(
+                    "packages",
+                    f"package_name='{package if isinstance(package, str) else package[0]}'",
+                    "package_version",
+                    q2_db=self.db_logic,
+                )
                 if pkg_ver != "":
                     try:
                         latest_version = version.parse(pkg_ver)
@@ -745,9 +760,10 @@ class Q2RadApp(Q2App):
                         continue
             self.process_events()
             if force or latest_version != current_version and latest_version:
+                self.pip_install(package, latest_version)
                 try:
                     self.pip_install(package, latest_version)
-                except Exception:
+                except Exception as error:
                     try:
                         self.pip_install(package, latest_version)
                     except Exception:
@@ -756,16 +772,20 @@ class Q2RadApp(Q2App):
                 latest_version, new_current_version = self.get_package_versions(package)
                 if latest_version:
                     upgraded.append(
-                        f"{package} - " f"<b>{current_version}</b> => " f"<b>{latest_version}</b>"
+                        f"{package if isinstance(package, str) else package[0]} - "
+                        f"<b>{current_version}</b> => "
+                        f"<b>{latest_version}</b>"
                     )
                 else:
-                    upgraded.append(f"Error occured while updating package <b>{package}</b>!")
+                    upgraded.append(
+                        "Error occured while updating package "
+                        f"<b>{package if isinstance(package, str) else package[0]}</b>!"
+                    )
         w.close()
         if upgraded:
             mess = ("Upgrading complete!<p>" "The program will be restarted!" "<p><p>") + "<p>".join(upgraded)
         else:
             mess = "Updates not found!<p>"
-        q2Mess(mess)
         if upgraded:
             self.restart()
 
@@ -819,11 +839,14 @@ class Q2RadApp(Q2App):
             trm = Q2Terminal(callback=print)
             trm.run(
                 f'"{sys.executable.replace("w.exe", ".exe")}" -m pip install '
-                f"--upgrade --no-cache-dir {package}=={latest_version}"
+                f"--upgrade --no-cache-dir {package if isinstance(package, str) else package[1]}"
+                f"=={latest_version}"
             )
             trm.close()
 
-        q2working(pip_runner, _("Installing package %s...") % package)
+        q2working(
+            pip_runner, _("Installing package %s...") % package if isinstance(package, str) else package[1]
+        )
 
     def pip_uninstall(self, package):
         if self.frozen:
@@ -869,7 +892,8 @@ class Q2RadApp(Q2App):
         if self.frozen:
             return
         extra_packages = [
-            x["package_name"] for x in q2cursor("select * from packages", self.db_logic).records()
+            (x["package_name"], x["package_pipname"])
+            for x in q2cursor("select * from packages", self.db_logic).records()
         ]
         self.check_packages_update(extra_packages)
 
@@ -900,13 +924,16 @@ class Q2RadApp(Q2App):
                             continue
                     except Exception as error:
                         q2mess(
-                            f"Error зparsing version for <b>{package}</b>:"
+                            f"Error parsing version for <b>{package}</b>:"
                             f"<br> {error}<br>"
                             f"<b>{package}</b> packages update skipped"
                         )
                         continue
             if latest_version != current_version and latest_version:
-                list_2_upgrade_message.append(f"<b>{package}</b>: {current_version} > {latest_version}")
+                list_2_upgrade_message.append(
+                    f"<b>{package if isinstance(package, str) else package[0]}</b>: "
+                    f"{current_version} > {latest_version}"
+                )
                 list_2_upgrade.append(package)
                 if not can_upgrade:
                     can_upgrade = True
@@ -1150,12 +1177,14 @@ class Q2RadApp(Q2App):
             in_def_indent = -1
             for x in script.split("\n"):
                 if x.strip() == "":
+                    new_script_lines.append("")
                     continue
                 spaces_count = count_leading_spaces(x)
                 # when in_def is True  - do not modify return
-                if in_def is False and re.findall(r"^\s*def|^\s*class", x):
-                    in_def = True
-                    in_def_indent = spaces_count
+                if re.findall(r"^\s*def|^\s*class", x):
+                    if in_def is False:
+                        in_def = True
+                        in_def_indent = spaces_count
                 elif spaces_count <= in_def_indent:
                     in_def = False
                     in_def_indent = -1
@@ -1164,8 +1193,6 @@ class Q2RadApp(Q2App):
                     if x.strip() == "return":
                         x = x.replace("return", "raise ReturnEvent")
                     else:
-                        # x = x.replace("return", "RETURN = ") + ";raise ReturnEvent"
-                        # x = x.replace("\n", "").replace("\r", "") + ";raise ReturnEvent"
                         x = x.replace("\n", "").replace("\r", "")
                         x = x.replace("return", "RETURN =")
                         x += ";raise ReturnEvent"
@@ -1218,7 +1245,7 @@ class Q2RadApp(Q2App):
             for x in args:
                 __locals_dict[x] = args[x]
             globals()["q2_app"] = self
-            return run_module(script=script, locals=__locals_dict)
+            return run_module(script=script, _locals=__locals_dict)
 
         return real_runner
 

{q2rad-0.1.207 → q2rad-0.1.209}/q2rad/q2utils.py

@@ -357,7 +357,7 @@ def q2choice(records=[], title="Make your choice", column_title=["Column"]):
 
 def choice_table():
     return q2choice(
-        [{"table": x} for x in q2app.q2_app.db_data.db_schema.get_schema_tables()],
+        [{"table": x} for x in q2app.q2_app.db_data.db_schema.get_schema_tables() if not x.startswith("log_")],
         title="Select table",
         column_title="Table",
     )

q2rad-0.1.209/q2rad/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.209"

q2rad-0.1.207/q2rad/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.207"