ardupilot-methodic-configurator 1.2.3__py3-none-any.whl → 1.4.0__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_component_editor_base.py

@@ -19,12 +19,13 @@ from logging import getLevelName as logging_getLevelName
 from logging import info as logging_info
 from sys import exit as sys_exit
 from tkinter import messagebox, ttk
-from typing import Union
+from typing import Any, Union
 
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_component_template_manager import ComponentTemplateManager
 from ardupilot_methodic_configurator.frontend_tkinter_rich_text import RichText
 from ardupilot_methodic_configurator.frontend_tkinter_scroll_frame import ScrollFrame
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_error_message, show_tooltip
@@ -84,7 +85,7 @@ class ComponentEditorWindowBase(BaseWindow):
         intro_frame.pack(side=tk.TOP, fill="x", expand=False)
 
         style = ttk.Style()
-        style.configure("bigger.TLabel", font=("TkDefaultFont", 14))
+        style.configure("bigger.TLabel", font=("TkDefaultFont", 13))
         style.configure("comb_input_invalid.TCombobox", fieldbackground="red")
         style.configure("comb_input_valid.TCombobox", fieldbackground="white")
         style.configure("entry_input_invalid.TEntry", fieldbackground="red")
@@ -92,9 +93,9 @@ class ComponentEditorWindowBase(BaseWindow):
         style.configure("Optional.TLabelframe", borderwidth=2)
         style.configure("Optional.TLabelframe.Label", foreground="gray")
 
-        explanation_text = _("Please configure all vehicle component properties in this window.\n")
-        explanation_text += _("Scroll down and make sure you do not miss a property.\n")
-        explanation_text += _("Saving the result will write to the vehicle_components.json file.")
+        explanation_text = _("Please configure properties of the vehicle components.\n")
+        explanation_text += _("Labels for optional properties are displayed in gray text.\n")
+        explanation_text += _("Scroll down to ensure that you do not overlook any properties.\n")
         explanation_label = ttk.Label(intro_frame, text=explanation_text, wraplength=800, justify=tk.LEFT)
         explanation_label.configure(style="bigger.TLabel")
         explanation_label.pack(side=tk.LEFT, padx=(10, 10), pady=(10, 0), anchor=tk.NW)
@@ -118,25 +119,41 @@ class ComponentEditorWindowBase(BaseWindow):
         self.save_button = ttk.Button(
             save_frame, text=_("Save data and start configuration"), command=self.validate_and_save_component_json
         )
-        show_tooltip(self.save_button, _("Save component data and start parameter value configuration and tuning."))
+        show_tooltip(
+            self.save_button,
+            _("Save component data to the vehicle_components.json file\nand start parameter value configuration and tuning."),
+        )
         self.save_button.pack(pady=7)
         if UsagePopupWindow.should_display("component_editor"):
             self.root.after(10, self.__display_component_editor_usage_instructions(self.root))  # type: ignore[arg-type]
 
+        def update_data_callback(comp_name: str, template_data: dict) -> None:
+            self.data["Components"][comp_name] = template_data
+
+        self.template_manager = ComponentTemplateManager(
+            self.root,
+            self.entry_widgets,
+            self.get_component_data_from_gui,
+            update_data_callback,
+            self.derive_initial_template_name,
+            local_filesystem.save_component_to_system_templates,
+        )
+
     @staticmethod
-    def __display_component_editor_usage_instructions(parent: tk.Toplevel) -> None:
+    def __display_component_editor_usage_instructions(parent: tk.Tk) -> None:
         usage_popup_window = BaseWindow(parent)
         style = ttk.Style()
 
         instructions_text = RichText(
             usage_popup_window.main_frame, wrap=tk.WORD, height=5, bd=0, background=style.lookup("TLabel", "background")
         )
-        instructions_text.insert(tk.END, _("1. Describe all vehicle component properties in the window below\n"))
-        instructions_text.insert(tk.END, _("2. Scroll all the way down and make sure to edit all properties\n"))
-        instructions_text.insert(tk.END, _("3. Do not be lazy, collect the required information and enter it\n"))
-        instructions_text.insert(tk.END, _("4. Press the "))
+        instructions_text.insert(tk.END, _("1. Describe the properties of the vehicle components in the window below.\n"))
+        instructions_text.insert(tk.END, _("2. Each field has mouse-over tooltips for additional guidance.\n"))
+        instructions_text.insert(tk.END, _("3. Optional fields are marked with gray text and can be left blank.\n"))
+        instructions_text.insert(tk.END, _("4. Scroll to the bottom of the window to ensure all properties are edited.\n"))
+        instructions_text.insert(tk.END, _("5. Press the "))
         instructions_text.insert(tk.END, _("Save data and start configuration"), "italic")
-        instructions_text.insert(tk.END, _(" only after all information is correct"))
+        instructions_text.insert(tk.END, _(" button only after verifying that all information is correct.\n"))
         instructions_text.config(state=tk.DISABLED)
 
         UsagePopupWindow.display(
@@ -166,73 +183,126 @@ class ComponentEditorWindowBase(BaseWindow):
         """Populates the ScrollFrame with widgets based on the JSON data."""
         if "Components" in self.data:
             for key, value in self.data["Components"].items():
-                self.__add_widget(self.scroll_frame.view_port, key, value, [])
+                self._add_widget(self.scroll_frame.view_port, key, value, [])
 
-    def __add_widget(self, parent: tk.Widget, key: str, value: dict, path: list) -> None:  # pylint: disable=too-many-locals
+    def _add_widget(self, parent: tk.Widget, key: str, value: Union[dict, float], path: list) -> None:
         """
         Adds a widget to the parent widget with the given key and value.
 
         Args:
             parent (tkinter.Widget): The parent widget to which the LabelFrame/Entry will be added.
             key (str): The key for the LabelFrame/Entry.
-            value (dict): The value associated with the key.
+            value (dict|float): The value associated with the key.
             path (list): The path to the current key in the JSON data.
 
         """
         if isinstance(value, dict):  # JSON non-leaf elements, add LabelFrame widget
-            is_toplevel = parent == self.scroll_frame.view_port
-            pady = 5 if is_toplevel else 3
+            self.__add_non_leaf_widget(parent, key, value, path)
+        else:  # JSON leaf elements, add Entry widget
+            self.__add_leaf_widget(parent, key, value, path)
+
+    def __add_non_leaf_widget(self, parent: tk.Widget, key: str, value: dict, path: list) -> None:
+        is_toplevel = parent == self.scroll_frame.view_port
+        pady = 5 if is_toplevel else 3
 
-            current_path = (*path, key)
-            description, is_optional = self.local_filesystem.get_component_property_description(current_path)
+        current_path = (*path, key)
+        description, is_optional = self.local_filesystem.get_component_property_description(current_path)
+        description = _(description) if description else ""
 
-            if is_optional:
-                frame = ttk.LabelFrame(parent, text=_(key), style="Optional.TLabelframe")
-            else:
-                frame = ttk.LabelFrame(parent, text=_(key))
+        if is_optional:
+            frame = ttk.LabelFrame(parent, text=_(key), style="Optional.TLabelframe")
+        else:
+            frame = ttk.LabelFrame(parent, text=_(key))
 
-            frame.pack(
-                fill=tk.X, side=tk.TOP if is_toplevel else tk.LEFT, pady=pady, padx=5, anchor=tk.NW if is_toplevel else tk.N
-            )
+        frame.pack(
+            fill=tk.X, side=tk.TOP if is_toplevel else tk.LEFT, pady=pady, padx=5, anchor=tk.NW if is_toplevel else tk.N
+        )
 
-            # Enhance tooltip for optional fields
-            if is_optional and description:
-                description += _("\nThis is optional and can be left blank")
+        # Enhance tooltip for optional fields
+        if is_optional and description:
+            description += _("\nThis is optional and can be left blank")
 
-            # Add tooltip based on schema description
-            if description:
-                show_tooltip(frame, _(description), position_below=False)
+        # Add tooltip based on schema description
+        if description:
+            show_tooltip(frame, description, position_below=False)
 
-            for sub_key, sub_value in value.items():
-                # recursively add child elements
-                self.__add_widget(frame, sub_key, sub_value, [*path, key])
-        else:  # JSON leaf elements, add Entry widget
-            entry_frame = ttk.Frame(parent)
-            entry_frame.pack(side=tk.TOP, fill=tk.X, pady=(0, 5))
+        if is_toplevel and key in self.data.get("Components", {}):
+            self._add_template_controls(frame, key)
+
+        for sub_key, sub_value in value.items():
+            # recursively add child elements
+            self._add_widget(frame, sub_key, sub_value, [*path, key])
+
+    def __add_leaf_widget(self, parent: tk.Widget, key: str, value: float, path: list) -> None:
+        entry_frame = ttk.Frame(parent)
+        entry_frame.pack(side=tk.TOP, fill=tk.X, pady=(0, 5))
+
+        description, is_optional = self.local_filesystem.get_component_property_description((*path, key))
+        description = _(description) if description else ""
 
-            description, is_optional = self.local_filesystem.get_component_property_description((*path, key))
+        label = ttk.Label(entry_frame, text=_(key), foreground="gray" if is_optional else "black")
 
-            if is_optional:
-                label = ttk.Label(entry_frame, text=_(key), foreground="gray")
-            else:
-                label = ttk.Label(entry_frame, text=_(key))
+        label.pack(side=tk.LEFT)
 
-            label.pack(side=tk.LEFT)
+        entry = self.add_entry_or_combobox(value, entry_frame, (*path, key), is_optional)
+        entry.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=(0, 5))
 
-            entry = self.add_entry_or_combobox(value, entry_frame, (*path, key))
-            entry.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=(0, 5))
+        # Store the entry widget in the entry_widgets dictionary for later retrieval
+        self.entry_widgets[(*path, key)] = entry
 
-            # Store the entry widget in the entry_widgets dictionary for later retrieval
-            self.entry_widgets[(*path, key)] = entry
+        # Enhance tooltip for optional fields
+        if is_optional and description:
+            description += _("\nThis is optional and can be left blank")
 
-            # Enhance tooltip for optional fields
-            if is_optional and description:
-                description += _("\nThis is optional and can be left blank")
+        # Add tooltip based on schema description
+        if description:
+            show_tooltip(label, description)
+            show_tooltip(entry, description)
 
-            # Add tooltip based on schema description
-            if description:
-                show_tooltip(label, _(description))
-                show_tooltip(entry, _(description))
+    def _add_template_controls(self, parent_frame: ttk.LabelFrame, component_name: str) -> None:
+        """Add template controls for a component."""
+        self.template_manager.add_template_controls(parent_frame, component_name)
+
+    def derive_initial_template_name(self, component_data: dict[str, Any]) -> str:  # pylint: disable=unused-argument # noqa: ARG002
+        """
+        Derive an initial template name from the component data.
+
+        This is a basic implementation that can be overridden in derived classes
+        to provide more specific template naming logic.
+        """
+        return ""
+
+    def get_component_data_from_gui(self, component_name: str) -> dict[str, Any]:
+        """Save the current component configuration as a template."""
+        # Get fresh component data from the GUI elements instead of stored data
+        component_data: dict[str, Any] = {}
+
+        # Find all entry widgets belonging to this component and extract their values
+        for path, entry in self.entry_widgets.items():
+            if len(path) >= 1 and path[0] == component_name:
+                # Get the current value from the entry widget
+                value: Union[str, int, float] = entry.get()
+
+                # Try to convert to appropriate type (int, float, or string)
+                if path[-1] != "Version":
+                    try:
+                        value = int(value)
+                    except ValueError:
+                        try:
+                            value = float(value)
+                        except ValueError:
+                            value = str(value).strip()
+
+                # Create nested structure by navigating through the path
+                current_level = component_data
+                for key in path[1:-1]:  # Skip component_name and the last key
+                    if key not in current_level:
+                        current_level[key] = {}
+                    current_level = current_level[key]
+
+                # Set the value at the final level
+                current_level[path[-1]] = value
+        return component_data
 
     def validate_and_save_component_json(self) -> None:
         """Saves the edited JSON data back to the file."""
@@ -294,7 +364,11 @@ class ComponentEditorWindowBase(BaseWindow):
 
     # This function will be overwritten in child classes
     def add_entry_or_combobox(
-        self, value: float, entry_frame: ttk.Frame, _path: tuple[str, str, str]
+        self,
+        value: float,
+        entry_frame: ttk.Frame,
+        _path: tuple[str, str, str],
+        is_optional: bool = False,  # pylint: disable=unused-argument # noqa: ARG002
     ) -> Union[ttk.Entry, ttk.Combobox]:
         entry = ttk.Entry(entry_frame)
         entry.insert(0, str(value))
@@ -318,6 +392,8 @@ if __name__ == "__main__":
 
     logging_basicConfig(level=logging_getLevelName(args.loglevel), format="%(asctime)s - %(levelname)s - %(message)s")
 
-    filesystem = LocalFilesystem(args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files)
+    filesystem = LocalFilesystem(
+        args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
+    )
     app = ComponentEditorWindowBase(__version__, filesystem)
     app.root.mainloop()

ardupilot_methodic_configurator/frontend_tkinter_component_template_manager.py

@@ -0,0 +1,196 @@
+"""
+Component template manager for the ArduPilot methodic configurator.
+
+This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+
+SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>, 2025 Francisco Fonseca
+
+SPDX-License-Identifier: GPL-3.0-or-later
+"""
+
+import tkinter as tk
+from collections.abc import Callable as CollectionsCallable
+from tkinter import Menu, messagebox, simpledialog, ttk
+from typing import Any, TypeVar, Union
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.backend_filesystem_vehicle_components import VehicleComponents
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
+
+T = TypeVar("T")
+
+
+class ComponentTemplateManager:  # pylint: disable=too-many-instance-attributes
+    """Manages component templates for the ArduPilot methodic configurator."""
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        root: Union[tk.Tk, tk.Toplevel],
+        entry_widgets: dict[tuple, Union[ttk.Entry, ttk.Combobox]],
+        get_component_data_callback: CollectionsCallable[[str], dict[str, Any]],
+        update_data_callback: CollectionsCallable[[str, dict[str, Any]], None],
+        derive_template_name_callback: CollectionsCallable[[dict[str, Any]], str],
+        save_component_to_system_templates: bool = False,
+    ) -> None:
+        """
+        Initialize the ComponentTemplateManager.
+
+        Args:
+            root: The root Tkinter window or toplevel widget
+            entry_widgets: Dictionary mapping component paths to entry widgets
+            get_component_data_callback: Callback to get component data
+            update_data_callback: Callback to update data when applying template
+            derive_template_name_callback: Callback to derive an initial template name from component
+            save_component_to_system_templates: Boolean save the component to the system file instead of the user file
+
+        """
+        self.root = root
+        self.entry_widgets = entry_widgets
+        self.buttons: dict[str, ttk.Button] = {}
+        self.current_menu: Union[Menu, None] = None
+        self.template_manager = VehicleComponents(save_component_to_system_templates)
+        self.get_component_data_callback = get_component_data_callback
+        self.update_data_callback = update_data_callback
+        self.derive_template_name_callback = derive_template_name_callback
+
+    def add_template_controls(self, parent_frame: ttk.LabelFrame, component_name: str) -> None:
+        """Add "template dropdown" and "save" buttons for a component."""
+        label_frame = ttk.Frame(parent_frame)
+        label_frame.pack(side=tk.TOP, fill=tk.X)
+
+        label = ttk.Label(label_frame, text=_("Template:"))
+        label.pack(side=tk.LEFT, padx=(5, 5))
+
+        # Create and add the template dropdown button
+        def show_template_for_component() -> None:
+            self.show_template_options(component_name)
+
+        dropdown_button = ttk.Button(label_frame, text="▼", width=2, command=show_template_for_component)
+        show_tooltip(dropdown_button, _("Select a template for this component"))
+        dropdown_button.pack(side=tk.LEFT)
+
+        # Create and add the save template button
+        def save_as_template() -> None:
+            self.save_component_as_template(component_name)
+
+        save_button = ttk.Button(label_frame, text="+", width=2, command=save_as_template)
+        show_tooltip(save_button, _("Save current configuration as template"))
+        save_button.pack(side=tk.LEFT, padx=(5, 0))
+
+        # Store the dropdown button reference
+        self.buttons[component_name] = dropdown_button
+
+    def save_component_as_template(self, component_name: str) -> None:
+        """Save the current component configuration as a template."""
+        component_data = self.get_component_data_callback(component_name)
+        if not component_data:
+            messagebox.showerror(_("Error"), _("No data for component: ") + component_name)
+            return
+
+        initial_template_name = self.derive_initial_template_name(component_data)
+        template_name = simpledialog.askstring(
+            _("Save Template"), _("Enter a name for this template:"), parent=self.root, initialvalue=initial_template_name
+        )
+        if not template_name:
+            return
+
+        templates = self.template_manager.load_component_templates()
+        if component_name not in templates:
+            templates[component_name] = []
+
+        new_template = {"name": template_name, "data": component_data, "is_user_modified": True}
+
+        for i, template in enumerate(templates[component_name]):
+            if template.get("name") == template_name:
+                confirm = messagebox.askyesno(_("Template exists"), _("A template with this name already exists. Overwrite?"))
+                if confirm:
+                    templates[component_name][i] = new_template
+                    self.template_manager.save_component_templates(templates)
+                    messagebox.showinfo(_("Template Saved"), _("Template has been updated"))
+                return
+
+        templates[component_name].append(new_template)
+        self.template_manager.save_component_templates(templates)
+        messagebox.showinfo(_("Template Saved"), _("Template has been saved"))
+
+    def derive_initial_template_name(self, component_data: dict[str, Any]) -> str:
+        """Derive an initial template name from the component data."""
+        return self.derive_template_name_callback(component_data)
+
+    def create_template_dropdown_button(self, parent: ttk.Frame, component_name: str) -> ttk.Button:
+        """Creates a dropdown button for component templates."""
+        button = ttk.Button(parent, text="▼", width=2, command=lambda: self.show_template_options(component_name))
+        show_tooltip(button, _("Select a template for this component"))
+        return button
+
+    def show_template_options(self, component_name: str) -> None:
+        """Shows a dropdown menu with template options for the component."""
+        if isinstance(self.current_menu, Menu):
+            self.current_menu.unpost()
+
+        button = self.buttons.get(component_name)
+        if not button:
+            return
+
+        templates = self.template_manager.load_component_templates()
+        component_templates = templates.get(component_name, [])
+        component_templates = sorted(component_templates, key=lambda x: x.get("name", "").lower())
+
+        menu = Menu(self.root, tearoff=0)
+
+        if component_templates:
+            for template in component_templates:
+                template_name = template.get("name", "Template")
+
+                # Create a command function with proper closure
+                command_function = self._create_template_apply_function(component_name, template)
+
+                menu.add_command(label=template_name, command=command_function)
+        else:
+            menu.add_command(label=_("No component templates available"), state="disabled")
+
+        x = button.winfo_rootx()
+        y = button.winfo_rooty() + button.winfo_height()
+        menu.post(x, y)
+
+        self.current_menu = menu
+
+        def close_menu(_: tk.Event) -> None:
+            if isinstance(self.current_menu, Menu):
+                self.current_menu.unpost()
+                self.current_menu = None
+                self.root.unbind("<Button-1>", close_handler_id)
+
+        close_handler_id = self.root.bind("<Button-1>", close_menu, add="+")
+
+    def _create_template_apply_function(self, component_name: str, template: dict) -> CollectionsCallable[[], None]:
+        """Create a function that will apply a template to a component when called."""
+
+        def apply_function() -> None:
+            self.apply_component_template(component_name, template)
+
+        return apply_function
+
+    def apply_component_template(self, component_name: str, template: dict) -> None:
+        """Apply a template to a component."""
+        if "data" not in template:
+            return
+
+        template_data = template["data"]
+
+        # Call the callback to update the main data structure
+        self.update_data_callback(component_name, template_data)
+
+        for path, entry in self.entry_widgets.items():
+            if len(path) >= 1 and path[0] == component_name:
+                value = template_data
+                try:
+                    for key in path[1:]:
+                        value = value[key]
+                    entry.delete(0, tk.END)
+                    entry.insert(0, str(value))
+                except (KeyError, TypeError):
+                    pass
+
+        template_name = template.get("name", "Template")
+        messagebox.showinfo(_("Template Applied"), _("{} has been applied to {}").format(template_name, component_name))

ardupilot_methodic_configurator/frontend_tkinter_connection_selection.py

@@ -23,7 +23,7 @@ from typing import Union
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_pair_tuple_combobox import PairTupleCombobox
 from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_no_connection_error, show_tooltip

ardupilot_methodic_configurator/frontend_tkinter_directory_selection.py

@@ -25,7 +25,7 @@ from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_no_param_files_error, show_tooltip
 from ardupilot_methodic_configurator.frontend_tkinter_template_overview import TemplateOverviewWindow
 
@@ -88,7 +88,8 @@ class DirectorySelectionWidgets:
 
     def on_select_directory(self) -> bool:
         if self.is_template_selection:
-            TemplateOverviewWindow(self.parent.root)
+            if isinstance(self.parent.root, tk.Tk):  # this keeps mypy and pyright happy
+                TemplateOverviewWindow(self.parent.root)
             selected_directory = ProgramSettings.get_recently_used_dirs()[0]
             logging_info(_("Selected template directory: %s"), selected_directory)
         else:
@@ -143,6 +144,7 @@ class DirectoryNameWidgets:  # pylint: disable=too-few-public-methods
 class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
     """
     A subclass of DirectorySelectionWidgets specifically tailored for selecting vehicle directories.
+
     This class extends the functionality of DirectorySelectionWidgets to handle vehicle-specific
     directory selections. It includes additional logic for updating the local filesystem with the
     selected vehicle directory and re-initializing the filesystem with the new directory.
@@ -554,7 +556,9 @@ def main() -> None:
     )
     # pylint: enable=duplicate-code
 
-    local_filesystem = LocalFilesystem(args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files)
+    local_filesystem = LocalFilesystem(
+        args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
+    )
 
     # Get the list of intermediate parameter files files that will be processed sequentially
     files = list(local_filesystem.file_parameters.keys())

ardupilot_methodic_configurator/frontend_tkinter_flightcontroller_info.py

@@ -17,7 +17,7 @@ from tkinter import ttk
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
-from ardupilot_methodic_configurator.frontend_tkinter_base import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 
 

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -37,7 +37,8 @@ from ardupilot_methodic_configurator.frontend_tkinter_rich_text import get_widge
 # https://dev.to/geraldew/python-tkinter-an-exercise-in-wrapping-the-combobox-ndb
 class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
     """
-    A custom Combobox widget that allows for the display of a list of tuples, where each tuple contains a key and a value.
+    A custom Combobox widget that displays a list of key-value tuples.
+
     This widget processes the list of tuples to separate keys and values for display purposes and allows for the selection
     of a tuple based on its key.
     """