Fixed GUI sometimes crashing when drag-and-dropping files, schema not found result, fixed source and destination binary files frames having different heights, results are now also updated when you drag-and-drop file that already exists in the source widget.

Author: Shararamosh

flatc_deserializer_frontend.py

@@ -3,14 +3,17 @@
 """
 # pylint: disable=import-error, too-many-instance-attributes, too-many-statements
 import os
+from collections.abc import Callable
+from importlib import import_module
 from tkinter import ttk
+
 from PIL.ImageTk import PhotoImage
 from PIL import Image
 from i18n import t
 import customtkinter as CTk
 from CTkMenuBar import CTkMenuBar
 from CTkMessagebox import CTkMessagebox
-import pywinstyles
+
 from main import init_localization, get_resource_path, execute_download, get_flatc_path, \
     get_binary_tuples
 from flatc_funcs import deserialize
@@ -56,14 +59,20 @@ def __init__(self):
                                                columns=("file", "file_size"), show="headings")
         self.src_binaries_table.heading("file", text=t("frontend.source_file_loc"))
         self.src_binaries_table.heading("file_size", text=t("frontend.file_size"))
-        self.src_binaries_table.pack(fill=CTk.BOTH, expand=True, padx=10, pady=10)
-        pywinstyles.apply_dnd(self.src_binaries_table.winfo_id(), self.on_binary_dropped)
+        self.src_binaries_frame.grid_rowconfigure(0, weight=1)
+        self.src_binaries_frame.grid_columnconfigure(0, weight=1)
+        self.src_binaries_frame.grid_propagate(False)
+        self.src_binaries_table.grid(row=0, column=0, padx=10, pady=10, sticky=CTk.NSEW)
+        self.attempt_apply_dnd(self.src_binaries_table.winfo_id(), self.on_binary_dropped)
         self.src_schemas_frame = ttk.LabelFrame(self.src_files_frame,
                                                 text=t("frontend.source_schemas"))
         self.src_schemas_frame.grid(row=1, column=0, padx=10, pady=10, sticky=CTk.NSEW)
         self.src_schemas_table = ttk.Treeview(self.src_schemas_frame, columns="file", show="")
-        self.src_schemas_table.pack(fill=CTk.BOTH, expand=True, padx=10, pady=10)
-        pywinstyles.apply_dnd(self.src_schemas_table.winfo_id(), self.on_schema_dropped)
+        self.src_schemas_frame.grid_rowconfigure(0, weight=1)
+        self.src_schemas_frame.grid_columnconfigure(0, weight=1)
+        self.src_schemas_frame.grid_propagate(False)
+        self.src_schemas_table.grid(row=0, column=0, padx=10, pady=10, sticky=CTk.NSEW)
+        self.attempt_apply_dnd(self.src_schemas_table.winfo_id(), self.on_schema_dropped)
         self.dest_files_frame = ttk.LabelFrame(self.files_frame,
                                                text=t("frontend.destination_files"))
         self.dest_files_frame.grid_rowconfigure(0, weight=1)
@@ -79,9 +88,13 @@ def __init__(self):
         self.dest_binaries_table.heading("file", text=t("frontend.destination_file_loc"))
         self.dest_binaries_table.heading("result", text=t("frontend.result"))
         self.dest_binaries_table.heading("file_size", text=t("frontend.file_size"))
-        self.dest_binaries_table.pack(fill=CTk.BOTH, expand=True, padx=10, pady=10)
+        self.dest_binaries_frame.grid_rowconfigure(0, weight=1)
+        self.dest_binaries_frame.grid_columnconfigure(0, weight=1)
+        self.dest_binaries_frame.grid_propagate(False)
+        self.dest_binaries_table.grid(row=0, column=0, padx=10, pady=10, sticky=CTk.NSEW)
         self.dest_options_frame = ttk.LabelFrame(self.dest_files_frame,
                                                  text=t("frontend.destination_options"))
+        self.dest_options_frame.grid_propagate(False)
         self.dest_options_frame.grid(row=1, column=0, padx=10, pady=10, sticky=CTk.NSEW)
         self.bottom_menu = CTkMenuBar(self, bg_color=None)
         img = Image.open(get_resource_path("images/flatbuffers-batch-logo-clean.png"))
@@ -90,6 +103,23 @@ def __init__(self):
         self.deserialize_button.configure(command=self.deserialize_button_pressed)
         self.bottom_menu.pack(side=CTk.RIGHT)
 
+    @staticmethod
+    def attempt_apply_dnd(widget_id: int, dnd_event: Callable):
+        """
+        Adding files drag-and-drop functionality to widget if it's supported.
+        :param widget_id: Widget ID.
+        :param dnd_event: Callable object for drag-and-drop event.
+        """
+        if os.name != "nt":
+            return
+        try:
+            mod = import_module("pywinstyles")
+        except ModuleNotFoundError:
+            return
+        fun = getattr(mod, "apply_dnd", None)
+        if fun is not None:
+            fun(widget_id, dnd_event)
+
     @staticmethod
     def flatc_button_pressed():
         """
@@ -118,17 +148,26 @@ def add_src_binary(self, file: str):
         binary_path = os.path.abspath(file)
         if os.path.splitext(binary_path)[1].lower() == ".json":
             return
+        binary_exists = self.src_binaries_table.exists(binary_path.casefold())
         src_values = (binary_path, t("frontend.size_kb") % (os.path.getsize(binary_path) / 1024))
         output_path = os.path.splitext(binary_path)[0] + ".json"
         if os.path.isfile(output_path):
             dest_values = (output_path, t("frontend.file_already_exists"),
                            t("frontend.size_kb") % (os.path.getsize(output_path) / 1024))
         else:
             dest_values = (output_path, "", "")
-        if self.src_binaries_table.exists(binary_path.casefold()):
-            return
-        self.src_binaries_table.insert("", "end", binary_path.casefold(), values=src_values)
-        self.dest_binaries_table.insert("", "end", binary_path.casefold(), values=dest_values)
+        if binary_exists:
+            for j in range(2):
+                self.src_binaries_table.set(binary_path.casefold(), j, src_values[j])
+            self.src_binaries_table.update()
+            for j in range(3):
+                self.dest_binaries_table.set(binary_path.casefold(), j, dest_values[j])
+            self.dest_binaries_table.update()
+        else:
+            self.src_binaries_table.insert("", "end", binary_path.casefold(), values=src_values)
+            self.src_binaries_table.update()
+            self.dest_binaries_table.insert("", "end", binary_path.casefold(), values=dest_values)
+            self.dest_binaries_table.update()
 
     def on_schema_dropped(self, paths: list[str]):
         """
@@ -154,6 +193,7 @@ def add_src_schema(self, file: str):
         if self.src_schemas_table.exists(schema_path.casefold()):
             return
         self.src_schemas_table.insert("", "end", schema_path.casefold(), values=[schema_path])
+        self.src_schemas_table.update()
 
     def deserialize_button_pressed(self):
         """
@@ -171,7 +211,7 @@ def deserialize_button_pressed(self):
                         self.dest_binaries_table.get_children("")]
         schema_paths = [self.src_schemas_table.set(i, 0) for i in
                         self.src_schemas_table.get_children("")]
-        binary_tuples = get_binary_tuples(binary_paths, schema_paths)
+        binary_tuples = get_binary_tuples(binary_paths, schema_paths, True)
         for i, binary_tuple in enumerate(binary_tuples):
             self.deserialize_and_update_table(flatc_path, binary_tuple[1], binary_tuple[0],
                                               output_paths[i])
@@ -187,14 +227,19 @@ def deserialize_and_update_table(self, flatc_path: str, schema_path: str, binary
         """
         json_path = deserialize(flatc_path, schema_path, binary_path, output_path, False)
         for i in self.dest_binaries_table.get_children(""):
-            if os.path.samefile(i, binary_path):
-                if json_path != "":
-                    self.dest_binaries_table.set(i, 1, t("frontend.result_done"))
-                    self.dest_binaries_table.set(i, 2, t("frontend.size_kb") % (
-                                os.path.getsize(json_path) / 1024))
-                else:
-                    self.dest_binaries_table.set(i, 1, t("frontend.result_error"))
-                    self.dest_binaries_table.set(i, 2, "")
+            if not os.path.samefile(i, binary_path):
+                continue
+            if json_path != "":
+                self.dest_binaries_table.set(i, 1, t("frontend.result_done"))
+                self.dest_binaries_table.set(i, 2, t("frontend.size_kb") % (
+                        os.path.getsize(json_path) / 1024))
+            elif not os.path.isfile(schema_path):
+                self.dest_binaries_table.set(i, 1, t("frontend.schema_not_found"))
+                self.dest_binaries_table.set(i, 2, "")
+            else:
+                self.dest_binaries_table.set(i, 1, t("frontend.result_error"))
+                self.dest_binaries_table.set(i, 2, "")
+            self.dest_binaries_table.update()
 
 
 if __name__ == "__main__":

flatc_funcs.py

@@ -9,7 +9,8 @@
 from i18n import t
 
 
-def deserialize(flatc_path: str, schema_path: str, binary_path: str, output_path: str = "", return_dict = True) -> dict:
+def deserialize(flatc_path: str, schema_path: str, binary_path: str, output_path: str = "",
+                return_dict=True) -> dict:
     """
     Десериализация бинарного файла, используя схему Flatbuffers.
     :param flatc_path: Путь к компилятору схемы.
@@ -19,6 +20,9 @@ def deserialize(flatc_path: str, schema_path: str, binary_path: str, output_path
     :param return_dict: Если True, возвращать словарь из прочитанного файла. Иначе - путь к файлу.
     :return: Десериализованный бинарный файл в виде словаря.
     """
+    if not os.path.isfile(flatc_path) or not os.path.isfile(schema_path) or not os.path.isfile(
+            binary_path):
+        return {} if return_dict else ""
     flatc_path = os.path.abspath(flatc_path)
     schema_path = os.path.abspath(schema_path)
     binary_path = os.path.abspath(binary_path)
@@ -46,27 +50,19 @@ def deserialize(flatc_path: str, schema_path: str, binary_path: str, output_path
         info(t("flatc_funcs.run_error"), " ".join(cpe.cmd), cpe.returncode)
         if cpe.stderr is not None and cpe.stderr != "":
             info(cpe.stderr)
-        if return_dict:
-            return {}
-        return ""
+        return {} if return_dict else ""
     if proc.stdout is not None and proc.stdout != "":
         info(t("flatc_funcs.run_ok"), " ".join(args))
         info(proc.stdout)
     if not os.path.isfile(json_path):
         info(t("flatc_funcs.json_error"), binary_path)
-        if return_dict:
-            return {}
-        return ""
+        return {} if return_dict else ""
     try:
         with open(json_path, "rb") as json_file:
             current_json_contents = json_file.read()
     except OSError:
         info(t("main.file_failed_to_open"), json_path)
-        if return_dict:
-            return {}
-        return ""
+        return {} if return_dict else ""
     if current_json_contents != previous_json_contents:
         info(t("flatc_funcs.json_ok"), binary_path, json_path)
-    if return_dict:
-        return loads(current_json_contents.decode("utf-8"))
-    return json_path
+    return loads(current_json_contents.decode("utf-8")) if return_dict else json_path

localization/en_US/frontend.yml

@@ -3,7 +3,7 @@ source_files: Source files
 source_binaries: Source binary files
 source_schemas: Source schemas
 destination_files: Destination files
-destination_binaries: Destination binaries
+destination_binaries: Destination binary files
 deserialize: Deserialize
 destination_options: Destination file options
 button_add: Add...
@@ -18,4 +18,5 @@ file_already_exists: File already exists
 flatc_not_found: Flatbuffers Schema Compiler (flatc) not found.
 error: Error
 result_done: Done
-result_error: Error
+result_error: Error
+schema_not_found: Schema not found

main.py

@@ -194,35 +194,46 @@ def get_schema_paths(root_path: str) -> list[str]:
     return schema_paths
 
 
-def get_binary_tuples(binary_paths: list[str], schema_paths: list[str]) -> list[tuple[str, str]]:
+def get_binary_tuples(binary_paths: list[str], schema_paths: list[str], return_empty_pairs: bool = False) -> list[tuple[str, str]]:
     """
     Получение списка кортежей из двух элементов: (путь к бинарному файлу, путь к соответствующему ему файлу схемы)
     :param binary_paths: Список путей к бинарным файлам или директориям с ними.
     :param schema_paths: Список путей к файлам схем.
+    :param return_empty_pairs: True, если необходимо добавить в список файлы, к которым нет схем.
     :return: Кортеж из двух строковых элементов.
     """
     binary_tuples = []
     for _, binary_path in enumerate(binary_paths):
         if os.path.isfile(binary_path):
+            schema_found = False
             file_path = os.path.abspath(binary_path)
             for schema_path in schema_paths:
                 schema_ext = os.path.splitext(os.path.basename(schema_path))[0]
                 file_ext = os.path.splitext(file_path)[1][1:]
                 if schema_ext.casefold() == file_ext.casefold():
+                    schema_found = True
                     binary_tuples.append((file_path, schema_path))
                     break
+            if not schema_found and return_empty_pairs:
+                binary_tuples.append((file_path, ""))
             continue
         if not os.path.isdir(binary_path):
+            if return_empty_pairs:
+                binary_tuples.append((binary_path, ""))
             continue
         for subdir, _, files in os.walk(binary_path):
             for file in files:
+                schema_found = False
                 file_path = os.path.abspath(os.path.join(subdir, file))
                 for schema_path in schema_paths:
                     schema_ext = os.path.splitext(os.path.basename(schema_path))[0]
                     file_ext = os.path.splitext(file_path)[1][1:]
                     if schema_ext.casefold() == file_ext.casefold():
+                        schema_found = True
                         binary_tuples.append((file_path, schema_path))
                         break
+                if not schema_found and return_empty_pairs:
+                    binary_tuples.append((file_path, ""))
     return binary_tuples