ardupilot-methodic-configurator 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

ardupilot_methodic_configurator/__init__.py

@@ -12,4 +12,4 @@ from ardupilot_methodic_configurator.internationalization import load_translatio
 
 _ = load_translation()
 
-__version__ = "2.5.0"
+__version__ = "2.6.0"

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -10,7 +10,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 # from sys import exit as sys_exit
 import glob
-import sys
+from importlib.resources import files as importlib_files
 from json import dump as json_dump
 from json import load as json_load
 from logging import debug as logging_debug
@@ -18,6 +18,7 @@ from logging import error as logging_error
 from os import makedirs as os_makedirs
 from os import path as os_path
 from os import sep as os_sep
+from pathlib import Path
 from platform import system as platform_system
 from re import escape as re_escape
 from re import match as re_match
@@ -107,13 +108,13 @@ class ProgramSettings:
 
     @staticmethod
     def application_icon_filepath() -> str:
-        script_dir = os_path.dirname(os_path.abspath(__file__))
-        return os_path.join(script_dir, "images", "ArduPilot_icon.png")
+        package_path = importlib_files("ardupilot_methodic_configurator")
+        return str(package_path / "images" / "ArduPilot_icon.png")
 
     @staticmethod
     def application_logo_filepath() -> str:
-        script_dir = os_path.dirname(os_path.abspath(__file__))
-        return os_path.join(script_dir, "images", "ArduPilot_logo.png")
+        package_path = importlib_files("ardupilot_methodic_configurator")
+        return str(package_path / "images" / "ArduPilot_logo.png")
 
     @staticmethod
     def create_new_vehicle_dir(new_vehicle_dir: str) -> str:
@@ -256,15 +257,14 @@ class ProgramSettings:
 
     @staticmethod
     def get_templates_base_dir() -> str:
-        current_script_dir = os_path.dirname(os_path.abspath(__file__))
+        package_path = importlib_files("ardupilot_methodic_configurator")
+        logging_debug("current script directory1: %s", package_path)
         if platform_system() == "Windows":
-            site_directory = ProgramSettings._site_config_dir()
-        else:
-            logging_debug("current script directory: %s", current_script_dir)
-            site_directory = current_script_dir
+            package_path = Path(ProgramSettings._site_config_dir())
+        logging_debug("current script directory2: %s", package_path)
 
-        logging_debug(_("site_directory: %s"), site_directory)
-        return os_path.join(site_directory, "vehicle_templates")
+        logging_debug(_("site_directory: %s"), package_path)
+        return str(package_path / "vehicle_templates")
 
     @staticmethod
     def get_recently_used_dirs() -> tuple[str, str, str]:
@@ -357,20 +357,15 @@ class ProgramSettings:
         """
         # See https://github.com/ArduPilot/ardupilot_wiki/pull/6215
         # Determine the application directory (where images are stored)
-        if getattr(sys, "frozen", False):
-            # Running as compiled executable
-            application_path = os_path.dirname(sys.executable)
-        else:
-            # Running as script
-            application_path = os_path.dirname(os_path.dirname(os_path.abspath(__file__)))
+        package_path = importlib_files("ardupilot_methodic_configurator")
 
-        images_dir = os_path.join(application_path, "ardupilot_methodic_configurator", "images", "motor_diagrams_png")
+        images_dir = package_path / "images" / "motor_diagrams_png"
 
         # Generate PNG filename based on frame configuration
         filename = f"m_{frame_class:02d}_{frame_type:02d}_*.png"
 
         # Search for matching PNG file (since exact naming varies)
-        matching_files = glob.glob(os_path.join(images_dir, filename))
+        matching_files = glob.glob(str(images_dir / filename))
 
         err_msg = (
             ""

ardupilot_methodic_configurator/configuration_manager.py

@@ -22,6 +22,8 @@ from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import download_file_from_url
+from ardupilot_methodic_configurator.data_model_ardupilot_parameter import ArduPilotParameter
+from ardupilot_methodic_configurator.data_model_configuration_step import ConfigurationStepProcessor
 from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict, is_within_tolerance
 from ardupilot_methodic_configurator.tempcal_imu import IMUfit
 
@@ -32,10 +34,19 @@ ShowWarningCallback = Callable[[str, str], None]  # (title, message) -> None
 ShowErrorCallback = Callable[[str, str], None]  # (title, message) -> None
 ShowInfoCallback = Callable[[str, str], None]  # (title, message) -> None
 
+
+class OperationNotPossibleError(Exception):
+    """Raised when an operation cannot be performed due to missing prerequisites or state."""
+
+
+class InvalidParameterNameError(Exception):
+    """Raised when a parameter name is invalid or already exists."""
+
+
 # pylint: disable=too-many-lines
 
 
-class ConfigurationManager:
+class ConfigurationManager:  # pylint: disable=too-many-public-methods
     """
     Manages configuration state, including flight controller and filesystem access.
 
@@ -48,6 +59,11 @@ class ConfigurationManager:
         self.current_file = current_file
         self.flight_controller = flight_controller
         self.filesystem = filesystem
+        self.config_step_processor = ConfigurationStepProcessor(self.filesystem)
+
+        # self.parameters is rebuilt on every repopulate(...) call and only contains the ArduPilotParameter
+        # objects needed for the current table view.
+        self.parameters: dict[str, ArduPilotParameter] = {}
 
     @property
     def connected_vehicle_type(self) -> str:
@@ -77,6 +93,10 @@ class ConfigurationManager:
             else False
         )
 
+    @property
+    def current_file_parameters(self) -> ParDict:
+        return self.filesystem.file_parameters.get(self.current_file, ParDict())
+
     def handle_imu_temperature_calibration_workflow(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
         selected_file: str,
@@ -1038,3 +1058,95 @@ class ConfigurationManager:
             show_info(_("Parameter files zipped"), msg.format(zip_file_path=zip_file_path))
 
         return should_write_file
+
+    def repopulate_configuration_step_parameters(
+        self,
+    ) -> tuple[bool, list[tuple[str, str]], list[tuple[str, str]]]:
+        """
+        Process the configuration step for the current file and update the self.parameters.
+
+        Returns:
+            tuple: (config_step_edited, ui_errors, ui_infos)
+
+        """
+        self.parameters, config_step_edited, ui_errors, ui_infos = self.config_step_processor.process_configuration_step(
+            self.current_file, self.fc_parameters
+        )
+        return config_step_edited, ui_errors, ui_infos
+
+    def get_different_parameters(self) -> dict[str, ArduPilotParameter]:
+        """
+        Get parameters that are different from FC values or missing from FC.
+
+        Returns:
+            Dictionary of parameters that are different from FC
+
+        """
+        return self.config_step_processor.filter_different_parameters(self.parameters)
+
+    def delete_parameter_from_current_file(self, param_name: str) -> None:
+        """
+        Delete a parameter from the current file parameters.
+
+        Args:
+            param_name: The name of the parameter to delete
+
+        """
+        del self.current_file_parameters[param_name]
+        if param_name in self.parameters:
+            del self.parameters[param_name]
+
+    def get_possible_add_param_names(self) -> list[str]:
+        """Return a sorted list of possible parameter names to add, or raise OperationNotPossibleError if not possible."""
+        param_dict = self.filesystem.doc_dict or self.fc_parameters
+        if not param_dict:
+            raise OperationNotPossibleError(
+                _("No apm.pdef.xml file and no FC connected. Not possible autocomplete parameter names.")
+            )
+        possible_add_param_names = [param_name for param_name in param_dict if param_name not in self.current_file_parameters]
+        possible_add_param_names.sort()
+        return possible_add_param_names
+
+    def add_parameter_to_current_file(self, param_name: str) -> bool:
+        """
+        Add a parameter to the current file.
+
+        Returns True if the parameter was added, False if not.
+
+        Raises InvalidParameterNameError or OperationNotPossibleError if not possible.
+        """
+        param_name = param_name.upper()
+        if not param_name:
+            raise InvalidParameterNameError(_("Parameter name can not be empty."))
+
+        if param_name in self.current_file_parameters:
+            raise InvalidParameterNameError(_("Parameter already exists, edit it instead"))
+
+        fc_parameters = self.fc_parameters
+        if fc_parameters:
+            if param_name in fc_parameters:
+                self.current_file_parameters[param_name] = Par(fc_parameters[param_name], "")
+                self.parameters[param_name] = self.config_step_processor.create_ardupilot_parameter(
+                    param_name, self.current_file_parameters[param_name], self.current_file, fc_parameters
+                )
+                return True
+            raise InvalidParameterNameError(_("Parameter name not found in the flight controller."))
+
+        if self.filesystem.doc_dict:
+            if param_name in self.filesystem.doc_dict:
+                self.current_file_parameters[param_name] = Par(
+                    self.filesystem.param_default_dict.get(param_name, Par(0, "")).value, ""
+                )
+                self.parameters[param_name] = self.config_step_processor.create_ardupilot_parameter(
+                    param_name, self.current_file_parameters[param_name], self.current_file, fc_parameters
+                )
+                return True
+            raise InvalidParameterNameError(
+                _("'{param_name}' not found in the apm.pdef.xml file.").format(param_name=param_name)
+            )
+
+        if not fc_parameters and not self.filesystem.doc_dict:
+            raise OperationNotPossibleError(
+                _("Can not add parameter when no FC is connected and no apm.pdef.xml file exists.")
+            )
+        return False

ardupilot_methodic_configurator/data_model_configuration_step.py

@@ -17,7 +17,7 @@ from typing import Any, Optional
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.data_model_ardupilot_parameter import ArduPilotParameter
-from ardupilot_methodic_configurator.data_model_par_dict import ParDict
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
 
 
 class ConfigurationStepProcessor:
@@ -38,11 +38,14 @@ class ConfigurationStepProcessor:
         """
         self.local_filesystem = local_filesystem
 
+        # A dictionary that maps variable names to their values
+        # These variables are used by the forced_parameters and derived_parameters in configuration_steps_*.json files
+        self.variables = self.local_filesystem.get_eval_variables()
+
     def process_configuration_step(
         self,
         selected_file: str,
         fc_parameters: dict[str, float],
-        variables: dict,
     ) -> tuple[dict[str, ArduPilotParameter], bool, list[tuple[str, str]], list[tuple[str, str]]]:
         """
         Process a configuration step including parameter computation and domain model creation.
@@ -50,7 +53,6 @@ class ConfigurationStepProcessor:
         Args:
             selected_file: The name of the selected parameter file
             fc_parameters: Dictionary of flight controller parameters
-            variables: Variables dictionary for evaluation
 
         Returns:
             Tuple containing:
@@ -66,6 +68,7 @@ class ConfigurationStepProcessor:
 
         # Process configuration step operations if configuration steps exist
         if self.local_filesystem.configuration_steps and selected_file in self.local_filesystem.configuration_steps:
+            variables = self.variables
             variables["fc_parameters"] = fc_parameters
 
             # Compute derived parameters
@@ -261,3 +264,37 @@ class ConfigurationStepProcessor:
                     renamed_pairs.append((old_name, new_name))
 
         return duplicates, renamed_pairs
+
+    def create_ardupilot_parameter(
+        self,
+        param_name: str,
+        param: Par,
+        selected_file: str,
+        fc_parameters: dict[str, float],
+    ) -> ArduPilotParameter:
+        """
+        Create an ArduPilotParameter domain model object.
+
+        Args:
+            param_name: The name of the parameter
+            param: The parameter object from the file
+            selected_file: The name of the selected parameter file
+            fc_parameters: Dictionary of flight controller parameters
+
+        Returns:
+            ArduPilotParameter: The created domain model parameter
+
+        """
+        # Get parameter metadata and default values
+        metadata = self.local_filesystem.doc_dict.get(param_name, {})
+        default_par = self.local_filesystem.param_default_dict.get(param_name, None)
+
+        # Check if parameter is forced or derived
+        forced_par = self.local_filesystem.forced_parameters.get(selected_file, ParDict()).get(param_name, None)
+        derived_par = self.local_filesystem.derived_parameters.get(selected_file, ParDict()).get(param_name, None)
+
+        # Get FC value if available
+        fc_value = fc_parameters.get(param_name)
+
+        # Create domain model parameter
+        return ArduPilotParameter(param_name, param, metadata, default_par, fc_value, forced_par, derived_par)

ardupilot_methodic_configurator/frontend_tkinter_base_window.py

@@ -281,9 +281,13 @@ class BaseWindow:
         parent_height = parent.winfo_height()
         window_width = window.winfo_width()
         window_height = window.winfo_height()
+        # logging_error(_("Parent position: %d,%d"), parent.winfo_x(), parent.winfo_y())
+        # logging_error(_("Parent size: %dx%d"), parent_width, parent_height)
+        # logging_error(_("Window size: %dx%d"), window_width, window_height)
         x = parent.winfo_x() + (parent_width // 2) - (window_width // 2)
         y = parent.winfo_y() + (parent_height // 2) - (window_height // 2)
         window.geometry(f"+{x}+{y}")
+        window.update()
 
     def put_image_in_label(  # pylint: disable=too-many-locals
         self,

ardupilot_methodic_configurator/frontend_tkinter_component_editor_base.py

@@ -289,7 +289,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         """Check if usage instructions should be displayed."""
         if UsagePopupWindow.should_display("component_editor"):
             # Cast to Tk since we know root is a Tk instance in this context
-            self.root.after(10, lambda: self._display_component_editor_usage_instructions(cast("tk.Tk", self.root)))
+            self.root.after(1, lambda: self._display_component_editor_usage_instructions(cast("tk.Tk", self.root)))
 
     def _display_component_editor_usage_instructions(self, parent: tk.Tk) -> None:
         """Display usage instructions for the component editor."""