ardupilot-methodic-configurator 2.1.2__py3-none-any.whl → 2.1.3__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_flightcontroller_info.py

@@ -14,8 +14,8 @@ from tkinter import messagebox, ttk
 from typing import Callable, Optional, Union
 
 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.data_model_par_dict import ParDict
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 
@@ -29,7 +29,7 @@ class FlightControllerInfoPresenter:
 
     def __init__(self, flight_controller: FlightController) -> None:
         self.flight_controller = flight_controller
-        self.param_default_values: dict[str, Par] = {}
+        self.param_default_values: ParDict = ParDict()
 
     def get_info_data(self) -> dict[str, Union[str, dict[str, str]]]:
         """Get formatted flight controller information for display."""
@@ -39,7 +39,7 @@ class FlightControllerInfoPresenter:
         """Log flight controller information."""
         self.flight_controller.info.log_flight_controller_info()
 
-    def download_parameters(self, progress_callback: Optional[Callable[[int, int], None]] = None) -> dict[str, Par]:
+    def download_parameters(self, progress_callback: Optional[Callable[[int, int], None]] = None) -> ParDict:
         """
         Download flight controller parameters.
 
@@ -55,7 +55,7 @@ class FlightControllerInfoPresenter:
         self.param_default_values = param_default_values
         return param_default_values
 
-    def get_param_default_values(self) -> dict[str, Par]:
+    def get_param_default_values(self) -> ParDict:
         """Get parameter default values."""
         return self.param_default_values
 
@@ -120,6 +120,6 @@ class FlightControllerInfoWindow(BaseWindow):
             param_download_progress_window.destroy()  # for the case that '--device test' and there is no real FC connected
             self.root.destroy()
 
-    def get_param_default_values(self) -> dict[str, Par]:
+    def get_param_default_values(self) -> ParDict:
         """Get parameter default values from the presenter."""
         return self.presenter.get_param_default_values()

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -150,7 +150,7 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         style = ttk.Style()
         # check if the combobox already has the "postoffset" property
         current_combo_style = combo.cget("style") or "TCombobox"
-        if len(style.lookup(current_combo_style, "postoffset")) > 0:  # type: ignore[no-untyped-call]
+        if len(style.lookup(current_combo_style, "postoffset")) > 0:
             return
         combo_values = combo.cget("values")
         if len(combo_values) == 0:
@@ -167,7 +167,7 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         style_name = current_combo_style if unique_name in current_combo_style else f"{unique_name}.{current_combo_style}"
 
         if isinstance(combo, ttk.Combobox):
-            style.configure(style_name, postoffset=(0, 0, width, 0))  # type: ignore[no-untyped-call]
+            style.configure(style_name, postoffset=(0, 0, width, 0))
             combo.configure(style=style_name)
 
 

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -28,12 +28,12 @@ from typing import Literal, Optional, Union
 from webbrowser import open as webbrowser_open  # to open the blog post documentation
 
 from ardupilot_methodic_configurator import _, __version__
-from ardupilot_methodic_configurator.annotate_params import Par
-from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem, is_within_tolerance
+from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import download_file_from_url
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict, is_within_tolerance
 from ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox import AutoResizeCombobox
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWidgets
@@ -164,15 +164,15 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.root.protocol("WM_DELETE_WINDOW", self.close_connection_and_quit)
 
         style = ttk.Style()
-        style.map("readonly.TCombobox", fieldbackground=[("readonly", "white")])  # type: ignore[no-untyped-call]
-        style.map("readonly.TCombobox", selectbackground=[("readonly", "white")])  # type: ignore[no-untyped-call]
-        style.map("readonly.TCombobox", selectforeground=[("readonly", "black")])  # type: ignore[no-untyped-call]
-        style.map("default_v.TCombobox", fieldbackground=[("readonly", "light blue")])  # type: ignore[no-untyped-call]
-        style.map("default_v.TCombobox", selectbackground=[("readonly", "light blue")])  # type: ignore[no-untyped-call]
-        style.map("default_v.TCombobox", selectforeground=[("readonly", "black")])  # type: ignore[no-untyped-call]
-        style.configure("default_v.TEntry", fieldbackground="light blue")  # type: ignore[no-untyped-call]
-        style.configure("below_limit.TEntry", fieldbackground="orangered")  # type: ignore[no-untyped-call]
-        style.configure("above_limit.TEntry", fieldbackground="red3")  # type: ignore[no-untyped-call]
+        style.map("readonly.TCombobox", fieldbackground=[("readonly", "white")])
+        style.map("readonly.TCombobox", selectbackground=[("readonly", "white")])
+        style.map("readonly.TCombobox", selectforeground=[("readonly", "black")])
+        style.map("default_v.TCombobox", fieldbackground=[("readonly", "light blue")])
+        style.map("default_v.TCombobox", selectbackground=[("readonly", "light blue")])
+        style.map("default_v.TCombobox", selectforeground=[("readonly", "black")])
+        style.configure("default_v.TEntry", fieldbackground="light blue")
+        style.configure("below_limit.TEntry", fieldbackground="orangered")
+        style.configure("above_limit.TEntry", fieldbackground="red3")
 
         self.__create_conf_widgets(__version__)
 
@@ -259,7 +259,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
     def legend_frame(self, config_subframe: ttk.Frame) -> None:  # pylint: disable=too-many-locals
         font_family, font_size = get_widget_font_family_and_size(config_subframe)
         style = ttk.Style()
-        style.configure("Legend.TLabelframe", font=(font_family, font_size))  # type: ignore[no-untyped-call]
+        style.configure("Legend.TLabelframe", font=(font_family, font_size))
         legend_frame = ttk.LabelFrame(config_subframe, text=_("Legend"), style="Legend.TLabelframe")
         legend_left = ttk.Frame(legend_frame)
         legend_left.pack(side=tk.LEFT, anchor=tk.NW)
@@ -402,7 +402,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             wrap=tk.WORD,
             height=10,
             bd=0,
-            background=style.lookup("TLabel", "background"),  # type: ignore[no-untyped-call]
+            background=style.lookup("TLabel", "background"),
         )
         instructions_text.insert(tk.END, _("1. Read "))
         instructions_text.insert(tk.END, _("all"), "bold")
@@ -517,7 +517,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             message_label.pack(padx=10, pady=10)
 
             # Result variable
-            result: list[Literal[None, True, False]] = [None]
+            result: list[Optional[Literal[True, False]]] = [None]
 
             # Button frame
             button_frame = tk.Frame(dialog)
@@ -696,7 +696,6 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         # Write each selected parameter to the flight controller
         for param_name, param in selected_params.items():
             try:
-                logging_info(_("Parameter %s set to %f"), param_name, param.value)
                 if param_name not in self.flight_controller.fc_parameters or not is_within_tolerance(
                     self.flight_controller.fc_parameters[param_name], param.value
                 ):
@@ -776,25 +775,52 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.on_skip_click()
 
     # This function can recurse multiple times if there is an upload error
-    def upload_selected_params(self, selected_params: dict) -> None:
+    def upload_selected_params(self, selected_params: dict) -> None:  # pylint: disable=too-many-branches
         logging_info(_("Uploading %d selected %s parameters to flight controller..."), len(selected_params), self.current_file)
 
         self.upload_params_that_require_reset(selected_params)
 
         # Write each selected parameter to the flight controller
+        nr_changed = 0
+        nr_unchanged = 0
         for param_name, param in selected_params.items():
             try:
                 self.flight_controller.set_param(param_name, param.value)
-                logging_info(_("Parameter %s set to %f"), param_name, param.value)
                 if param_name not in self.flight_controller.fc_parameters or not is_within_tolerance(
                     self.flight_controller.fc_parameters[param_name], param.value
                 ):
                     self.at_least_one_changed_parameter_written = True
+                    if param_name in self.flight_controller.fc_parameters:
+                        logging_info(
+                            _("Parameter %s changed from %f to %f"),
+                            param_name,
+                            self.flight_controller.fc_parameters[param_name],
+                            param.value,
+                        )
+                    else:
+                        logging_info(
+                            _("Parameter %s changed to %f"),
+                            param_name,
+                            param.value,
+                        )
+                    nr_changed += 1
+                else:
+                    logging_info(_("Parameter %s unchanged from %f"), param_name, param.value)
+                    nr_unchanged += 1
             except ValueError as _e:  # noqa: PERF203
                 error_msg = _("Failed to set parameter {param_name}: {_e}").format(**locals())
                 logging_error(error_msg)
                 messagebox.showerror(_("ArduPilot methodic configurator"), error_msg)
 
+        changed_msg = _("%d FC parameter(s) changed value") % nr_changed if nr_changed else ""
+        unchanged_msg = (
+            _("%d FC parameter(s) already had the value defined in this configuration step") % nr_unchanged
+            if nr_unchanged
+            else ""
+        )
+        msg = changed_msg + (", " if nr_changed and nr_unchanged else "") + unchanged_msg
+        logging_info(msg)
+
         if self.at_least_one_changed_parameter_written:
             # Re-download all parameters, in case one of them changed, and validate that all uploads were successful
             self.download_flight_controller_parameters(redownload=True)
@@ -832,8 +858,55 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                     self.upload_selected_params(selected_params)
             else:
                 logging_info(_("All parameters uploaded to the flight controller successfully"))
+
+            # Export FC parameters that are missing or different from AMC parameter files
+            self._export_fc_params_missing_or_different_in_amc_files()
+
         self.local_filesystem.write_last_uploaded_filename(self.current_file)
 
+    def _export_fc_params_missing_or_different_in_amc_files(self) -> None:
+        """
+        Export flight controller parameters that are missing or different in AMC parameter files.
+
+        This function creates a compound state of all parameters from AMC files (excluding defaults),
+        compares them with FC parameters, and exports any parameters that are either missing from
+        AMC files or have different values to a separate parameter file.
+        """
+        # Create the compounded state of all parameters stored in the AMC .param files
+        compound = ParDict()
+        for file_name, file_params in self.local_filesystem.file_parameters.items():
+            if file_name != "00_default.param":
+                compound.append(file_params)
+
+        # Create FC parameters dictionary
+        fc_parameters = ParDict.from_fc_parameters(self.flight_controller.fc_parameters)
+
+        # Remove default parameters from FC parameters if default file exists
+        fc_parameters.remove_if_value_is_similar(self.local_filesystem.param_default_dict, is_within_tolerance)
+
+        # Ignore read-only parameters
+        read_only_parameter_names = [
+            param_name for param_name, metadata in self.local_filesystem.doc_dict.items() if metadata.get("ReadOnly", False)
+        ]
+        for param_name in read_only_parameter_names:
+            if param_name in fc_parameters:
+                del fc_parameters[param_name]
+
+        # Calculate parameters that only exist in fc_parameters or have a different value from compound
+        params_missing_in_the_amc_param_files = fc_parameters.get_missing_or_different(compound, is_within_tolerance)
+
+        # Export to file if there are any missing/different parameters
+        if params_missing_in_the_amc_param_files:
+            filename = "fc_params_missing_or_different_in_the_amc_param_files.param"
+            self.local_filesystem.export_to_param(params_missing_in_the_amc_param_files, filename, annotate_doc=False)
+            logging_info(
+                _("Exported %d FC parameters missing or different in AMC files to %s"),
+                len(params_missing_in_the_amc_param_files),
+                filename,
+            )
+        else:
+            logging_info(_("No FC parameters are missing or different from AMC parameter files"))
+
     def _configuration_step_is_optional(self, file_name: str, threshold_pct: int = 20) -> bool:
         # Check if the configuration step for the given file is optional
         mandatory_text, _mandatory_url = self.local_filesystem.get_documentation_text_and_url(file_name, "mandatory")
@@ -959,7 +1032,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         ]
         self.write_zip_file(files_to_zip)
 
-    def write_summary_file(self, param_dict: dict, filename: str, annotate_doc: bool) -> bool:
+    def write_summary_file(self, param_dict: ParDict, filename: str, annotate_doc: bool) -> bool:
         should_write_file = True
         if param_dict:
             if self.local_filesystem.vehicle_configuration_file_exists(filename):

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -19,7 +19,6 @@ from tkinter import messagebox, ttk
 from typing import Union
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.data_model_ardupilot_parameter import (
     ArduPilotParameter,
@@ -28,6 +27,7 @@ from ardupilot_methodic_configurator.data_model_ardupilot_parameter import (
     ParameterUnchangedError,
 )
 from ardupilot_methodic_configurator.data_model_configuration_step import ConfigurationStepProcessor
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_entry_dynamic import EntryWithDynamicalyFilteredListbox
 from ardupilot_methodic_configurator.frontend_tkinter_pair_tuple_combobox import (
@@ -65,7 +65,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         self._last_return_values: dict[tk.Misc, str] = {}
 
         style = ttk.Style()
-        style.configure("narrow.TButton", padding=0, width=4, border=(0, 0, 0, 0))  # type: ignore[no-untyped-call]
+        style.configure("narrow.TButton", padding=0, width=4, border=(0, 0, 0, 0))
 
         # Prepare 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
@@ -295,7 +295,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             if param.is_readonly
             else "yellow"
             if param.is_calibration
-            else ttk.Style(self.root).lookup("TFrame", "background"),  # type: ignore[no-untyped-call]
+            else ttk.Style(self.root).lookup("TFrame", "background"),
         )
 
         tooltip_parameter_name = param.tooltip_new_value
@@ -828,14 +828,14 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             )
         return False
 
-    def get_upload_selected_params(self, current_file: str, gui_complexity: str) -> dict[str, Par]:
+    def get_upload_selected_params(self, current_file: str, gui_complexity: str) -> ParDict:
         """Get the parameters selected for upload."""
         # Check if we should show upload column based on GUI complexity
         if not self._should_show_upload_column(gui_complexity):
             # all parameters are selected for upload in simple mode
             return self.local_filesystem.file_parameters[current_file]
 
-        selected_params = {}
+        selected_params = ParDict()
         for param_name, checkbutton_state in self.upload_checkbutton_var.items():
             if checkbutton_state.get():
                 selected_params[param_name] = self.local_filesystem.file_parameters[current_file][param_name]

ardupilot_methodic_configurator/frontend_tkinter_rich_text.py

@@ -75,7 +75,7 @@ def get_widget_font_family_and_size(widget: tk.Widget) -> tuple[str, int]:
     """
     style = ttk.Style()
     widget_style = widget.cget("style")  # Get the style used by the widget
-    font_name = style.lookup(widget_style, "font")  # type: ignore[no-untyped-call]
+    font_name = style.lookup(widget_style, "font")
     font_dict = tkFont.nametofont(font_name).config()
 
     default_font_family = "Segoe UI" if platform_system() == "Windows" else "Helvetica"

ardupilot_methodic_configurator/frontend_tkinter_scroll_frame.py

@@ -33,7 +33,7 @@ class ScrollFrame(ttk.Frame):  # pylint: disable=too-many-ancestors
         self.canvas = tk.Canvas(
             self,
             borderwidth=0,
-            background=ttk.Style(master).lookup("TFrame", "background"),  # type: ignore[no-untyped-call]
+            background=ttk.Style(master).lookup("TFrame", "background"),
         )
 
         # place a frame on the canvas, this frame will hold the child widgets

ardupilot_methodic_configurator/frontend_tkinter_template_overview.py

@@ -179,7 +179,7 @@ class TemplateOverviewWindow(BaseWindow):
         """Setup treeview styling with DPI scaling."""
         style = ttk.Style(self.root)
         # Add padding to Treeview heading style
-        style.layout(  # type: ignore[no-untyped-call]
+        style.layout(
             "Treeview.Heading",
             [
                 ("Treeview.Heading.cell", {"sticky": "nswe"}),
@@ -210,7 +210,7 @@ class TemplateOverviewWindow(BaseWindow):
             self.calculate_scaled_padding(2),
             self.calculate_scaled_padding(18),
         ]
-        style.configure("Treeview.Heading", padding=scaled_padding, justify="center")  # type: ignore[no-untyped-call]
+        style.configure("Treeview.Heading", padding=scaled_padding, justify="center")
 
     def _setup_treeview_columns(self) -> None:
         """Setup treeview column headers."""

ardupilot_methodic_configurator/param_pid_adjustment_update.py

@@ -17,15 +17,14 @@ SPDX-License-Identifier: GPL-3.0-or-later
 import argparse
 import os
 import re
-import subprocess
-from typing import Callable, Optional, Union
+from typing import Callable, Union
 
 import argcomplete
 from argcomplete.completers import DirectoriesCompleter, FilesCompleter
 
-PARAM_NAME_REGEX = r"^[A-Z][A-Z_0-9]*$"
-PARAM_NAME_MAX_LEN = 16
-VERSION = "1.0"
+from ardupilot_methodic_configurator.data_model_par_dict import PARAM_NAME_MAX_LEN, PARAM_NAME_REGEX, Par, ParDict
+
+VERSION = "1.1"
 
 
 def create_argument_parser() -> argparse.ArgumentParser:
@@ -52,9 +51,9 @@ explaining how their new value relates to the default parameter value.
     parser.add_argument(
         "-a",
         "--adjustment_factor",
-        type=ranged_type(float, 0.1, 0.8),
+        type=ranged_type(float, 0.1, 1.2),
         default=0.5,
-        help="The adjustment factor to apply to the optimized parameters. Must be in the interval 0.1 to 0.8. Default is 0.5.",
+        help="The adjustment factor to apply to the optimized parameters. Must be in the interval 0.1 to 1.2. Default is 0.5.",
     )
     parser.add_argument(
         "-v",
@@ -98,77 +97,65 @@ def ranged_type(value_type: type, min_value: float, max_value: float) -> Callabl
     return range_checker
 
 
-class Par:
+def load_param_file_with_content(param_file: str) -> tuple[ParDict, list[str]]:
     """
-    A class representing a parameter with a value and an optional comment.
+    Load parameter file into ParDict and return the file content as well.
 
-    Attributes:
-        value (float): The value of the parameter.
-        comment (str): An optional comment describing the parameter.
+    This is a helper function that extends ParDict.load_param_file_into_dict()
+    to also return the original file content lines for header preservation.
 
-    """
+    Args:
+        param_file: Path to the parameter file.
 
-    def __init__(self, value: float, comment: Optional[str] = None) -> None:
-        self.value = value
-        self.comment = comment
-
-    @staticmethod
-    def load_param_file_into_dict(param_file: str) -> tuple[dict[str, "Par"], list[str]]:
-        parameter_dict = {}
-        content = []
-        with open(param_file, encoding="utf-8") as f_handle:
-            for n, f_line in enumerate(f_handle, start=1):
-                line = f_line.strip()
-                content.append(line)
-                comment = None
-                if not line or line.startswith("#"):
-                    continue
-                if "#" in line:
-                    line, comment = line.split("#", 1)
-                    comment = comment.strip()
-                if "," in line:
-                    parameter, value = line.split(",", 1)
-                elif " " in line:
-                    parameter, value = line.split(" ", 1)
-                elif "\t" in line:
-                    parameter, value = line.split("\t", 1)
-                else:
-                    msg = f"Missing parameter-value separator: {line} in {param_file} line {n}"
-                    raise SystemExit(msg)
-                if len(parameter) > PARAM_NAME_MAX_LEN:
-                    msg = f"Too long parameter name: {parameter} in {param_file} line {n}"
-                    raise SystemExit(msg)
-                if not re.match(PARAM_NAME_REGEX, parameter):
-                    msg = f"Invalid characters in parameter name {parameter} in {param_file} line {n}"
-                    raise SystemExit(msg)
-                try:
-                    fvalue = float(value)
-                except ValueError as exc:
-                    msg = f"Invalid parameter value {value} in {param_file} line {n}"
-                    raise SystemExit(msg) from exc
-                if parameter in parameter_dict:
-                    msg = f"Duplicated parameter {parameter} in {param_file} line {n}"
-                    raise SystemExit(msg)
-                parameter_dict[parameter] = Par(fvalue, comment)
-        return parameter_dict, content
-
-    @staticmethod
-    def export_to_param(param_dict: dict[str, "Par"], filename_out: str, content_header: Optional[list[str]] = None) -> None:
-        if content_header is None:
-            content_header = []
-        with open(filename_out, "w", encoding="utf-8") as output_file:
-            if content_header:
-                output_file.write("\n".join(content_header) + "\n")
-            for key, par in param_dict.items():
-                line = f"{key},{format(par.value, '.6f').rstrip('0').rstrip('.')}"
-                if par.comment:
-                    line += f"  # {par.comment}"
-                output_file.write(line + "\n")
+    Returns:
+        A tuple of (ParDict, list of file content lines).
+
+    """
+    parameter_dict = ParDict()
+    content = []
+    with open(param_file, encoding="utf-8") as f_handle:
+        for n, f_line in enumerate(f_handle, start=1):
+            line = f_line.strip()
+            content.append(line)
+            comment = None
+            if not line or line.startswith("#"):
+                continue
+            if "#" in line:
+                line, comment = line.split("#", 1)
+                comment = comment.strip()
+            if "," in line:
+                parameter, value = line.split(",", 1)
+            elif " " in line:
+                parameter, value = line.split(" ", 1)
+            elif "\t" in line:
+                parameter, value = line.split("\t", 1)
+            else:
+                msg = f"Missing parameter-value separator: {line} in {param_file} line {n}"
+                raise SystemExit(msg)
+            # Strip whitespace from both parameter name and value immediately after splitting
+            parameter = parameter.strip()
+            value = value.strip()
+            if len(parameter) > PARAM_NAME_MAX_LEN:
+                msg = f"Too long parameter name: {parameter} in {param_file} line {n}"
+                raise SystemExit(msg)
+            if not re.match(PARAM_NAME_REGEX, parameter):
+                msg = f"Invalid characters in parameter name {parameter} in {param_file} line {n}"
+                raise SystemExit(msg)
+            try:
+                fvalue = float(value)
+            except ValueError as exc:
+                msg = f"Invalid parameter value {value} in {param_file} line {n}"
+                raise SystemExit(msg) from exc
+            if parameter in parameter_dict:
+                msg = f"Duplicated parameter {parameter} in {param_file} line {n}"
+                raise SystemExit(msg)
+            parameter_dict[parameter] = Par(fvalue, comment)
+    return parameter_dict, content
 
 
 def update_pid_adjustment_params(
     directory: str, optimized_param_file: str, adjustment_factor: float
-) -> tuple[dict[str, "Par"], str, list[str]]:
+) -> tuple[ParDict, str, list[str]]:
     """
     Updates the PID adjustment parameters values based on the given adjustment factor.
 
@@ -189,13 +176,13 @@ def update_pid_adjustment_params(
     pid_adjustment_file_path = os.path.join(directory, "16_pid_adjustment.param")
 
     # Load the default parameter file into a dictionary (comment source)
-    default_params_dict, _ = Par.load_param_file_into_dict(default_param_file_path)
+    default_params_dict = ParDict.from_file(default_param_file_path)
 
     # Load the optimized parameter file into a dictionary (source)
-    optimized_params_dict, _ = Par.load_param_file_into_dict(optimized_param_file_path)
+    optimized_params_dict = ParDict.from_file(optimized_param_file_path)
 
     # Load the PID adjustment parameter file into a dictionary (destination)
-    pid_adjustment_params_dict, content = Par.load_param_file_into_dict(pid_adjustment_file_path)
+    pid_adjustment_params_dict, content = load_param_file_with_content(pid_adjustment_file_path)
 
     if not default_params_dict:
         msg = f"Failed to load default parameters from {default_param_file_path}"
@@ -240,9 +227,7 @@ def main() -> None:
         args.directory, args.optimized_param_file, args.adjustment_factor
     )
     # export the updated PID adjust parameters to a file, preserving the first eight header lines
-    Par.export_to_param(pid_adjustment_params_dict, pid_adjustment_file_path, content_header)
-    # annotate each parameter with up-to date documentation
-    subprocess.run(["./annotate_params.py", os.path.join(args.directory, "16_pid_adjustment.param")], check=True)  # noqa: S603
+    pid_adjustment_params_dict.export_to_param(pid_adjustment_file_path, content_header=content_header)
 
 
 if __name__ == "__main__":

{ardupilot_methodic_configurator-2.1.2.dist-info → ardupilot_methodic_configurator-2.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ardupilot_methodic_configurator
-Version: 2.1.2
+Version: 2.1.3
 Summary: A clear configuration sequence for ArduPilot vehicles
 Author-email: Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 Maintainer-email: Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
@@ -64,17 +64,17 @@ Requires-Dist: requests==2.32.5
 Provides-Extra: dev
 Requires-Dist: coverage==7.10.6; extra == "dev"
 Requires-Dist: mock==5.2.0; extra == "dev"
-Requires-Dist: mypy==1.17.1; extra == "dev"
+Requires-Dist: mypy==1.18.1; extra == "dev"
 Requires-Dist: pre-commit==4.3.0; extra == "dev"
 Requires-Dist: pylint==3.3.8; extra == "dev"
 Requires-Dist: pyright==1.1.405; extra == "dev"
 Requires-Dist: pytest==8.4.2; extra == "dev"
-Requires-Dist: pytest-cov==6.3.0; extra == "dev"
+Requires-Dist: pytest-cov==7.0.0; extra == "dev"
 Requires-Dist: pytest-md==0.2.0; extra == "dev"
 Requires-Dist: pytest-mock==3.15.0; extra == "dev"
 Requires-Dist: python-gettext==5.0; extra == "dev"
-Requires-Dist: ruff==0.12.12; extra == "dev"
-Requires-Dist: types-requests==2.32.4.20250809; extra == "dev"
+Requires-Dist: ruff==0.13.0; extra == "dev"
+Requires-Dist: types-requests==2.32.4.20250913; extra == "dev"
 Provides-Extra: scripts
 Requires-Dist: bs4; extra == "scripts"
 Provides-Extra: pypi-dist
@@ -86,7 +86,7 @@ Provides-Extra: win-dist
 Requires-Dist: wheel==0.45.1; extra == "win-dist"
 Requires-Dist: pip==25.2; extra == "win-dist"
 Requires-Dist: pywin32==311; extra == "win-dist"
-Requires-Dist: pyinstaller==6.15.0; extra == "win-dist"
+Requires-Dist: pyinstaller==6.16.0; extra == "win-dist"
 Requires-Dist: packaging==25.0; extra == "win-dist"
 Dynamic: license-file