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

ardupilot_methodic_configurator/backend_filesystem.py

@@ -21,6 +21,7 @@ from os import path as os_path
 from os import remove as os_remove
 from os import rename as os_rename
 from os import rmdir as os_rmdir
+from pathlib import Path
 from platform import system as platform_system
 from re import compile as re_compile
 from shutil import Error as shutil_Error
@@ -36,7 +37,6 @@ from argcomplete.completers import DirectoriesCompleter
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.annotate_params import (
     PARAM_DEFINITION_XML_FILE,
-    Par,
     format_columns,
     get_xml_dir,
     get_xml_url,
@@ -48,31 +48,11 @@ from ardupilot_methodic_configurator.annotate_params import (
 from ardupilot_methodic_configurator.backend_filesystem_configuration_steps import ConfigurationSteps
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.backend_filesystem_vehicle_components import VehicleComponents
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict, is_within_tolerance
 
 TOOLTIP_MAX_LENGTH = 105
 
 
-def is_within_tolerance(x: float, y: float, atol: float = 1e-08, rtol: float = 1e-04) -> bool:
-    """
-    Determines if the absolute difference between two numbers is within a specified tolerance.
-
-    This function checks if the absolute difference between `x` and `y` is less than or equal to
-    the sum of the absolute tolerance (`atol`) and the product of the relative tolerance (`rtol`)
-    and the absolute value of `y`.
-
-    Args:
-      x (float): The first number to compare.
-      y (float): The second number to compare.
-      atol (float, optional): The absolute tolerance. Default is 1e-08.
-      rtol (float, optional): The relative tolerance. Default is 1e-04.
-
-    Returns:
-      bool: True if the difference is within the tolerance, False otherwise.
-
-    """
-    return abs(x - y) <= atol + (rtol * abs(y))
-
-
 class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):  # pylint: disable=too-many-public-methods
     """
     A class to manage local filesystem operations for the ArduPilot methodic configurator.
@@ -84,9 +64,6 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
     Args:
         vehicle_dir (str): The directory path where the vehicle configuration files are stored.
         vehicle_type (str): The type of the vehicle (e.g., "ArduCopter", "Rover").
-        file_parameters (dict): A dictionary of parameters read from intermediate parameter files.
-        param_default_dict (dict): A dictionary of default parameter values.
-        doc_dict (dict): A dictionary containing documentation for each parameter.
 
     """
 
@@ -98,14 +75,14 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         allow_editing_template_files: bool,
         save_component_to_system_templates: bool,
     ) -> None:
-        self.file_parameters: dict[str, dict[str, Par]] = {}
+        self.file_parameters: dict[str, ParDict] = {}
         VehicleComponents.__init__(self, save_component_to_system_templates)
         ConfigurationSteps.__init__(self, vehicle_dir, vehicle_type)
         ProgramSettings.__init__(self)
         self.vehicle_type = vehicle_type
         self.fw_version = fw_version
         self.allow_editing_template_files = allow_editing_template_files
-        self.param_default_dict: dict[str, Par] = {}
+        self.param_default_dict: ParDict = ParDict()
         self.vehicle_dir = vehicle_dir
         self.doc_dict: dict[str, Any] = {}
         if vehicle_dir is not None:
@@ -147,7 +124,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         xml_url = get_xml_url(vehicle_type, self.fw_version)
         xml_dir = get_xml_dir(vehicle_dir)
         self.doc_dict = parse_parameter_metadata(xml_url, xml_dir, PARAM_DEFINITION_XML_FILE, vehicle_type, TOOLTIP_MAX_LENGTH)
-        self.param_default_dict = load_default_param_file(xml_dir)
+        self.param_default_dict = load_default_param_file(vehicle_dir)
 
         # Extend parameter documentation metadata if <parameter_file>.pdef.xml exists
         for filename in self.file_parameters:
@@ -159,16 +136,21 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         self.__extend_and_reformat_parameter_documentation_metadata()
 
     def vehicle_configuration_files_exist(self, vehicle_dir: str) -> bool:
-        if os_path.exists(vehicle_dir) and os_path.isdir(vehicle_dir):
-            vehicle_configuration_files = os_listdir(vehicle_dir)
-            if platform_system() == "Windows":
-                vehicle_configuration_files = [f.lower() for f in vehicle_configuration_files]
-            pattern = re_compile(r"^\d{2}_.*\.param$")
-            if self.vehicle_components_fs.json_filename in vehicle_configuration_files and any(
-                pattern.match(f) for f in vehicle_configuration_files
-            ):
-                return True
-        return False
+        vehicle_path = Path(vehicle_dir)
+        if not (vehicle_path.exists() and vehicle_path.is_dir()):
+            return False
+
+        # Use generator expression for better memory efficiency
+        files = (f.name for f in vehicle_path.iterdir() if f.is_file())
+
+        if platform_system() == "Windows":
+            files = (f.lower() for f in files)
+
+        # Convert to set for O(1) lookup performance and compile pattern once
+        file_set = set(files)
+        pattern = re_compile(r"^\d{2}_.*\.param$")
+
+        return self.vehicle_components_fs.json_filename in file_set and any(pattern.match(f) for f in file_set)
 
     def rename_parameter_files(self) -> None:
         if self.vehicle_dir is None or self.configuration_steps is None:
@@ -191,7 +173,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                         os_rename(old_filename_path, new_filename_path)
                         logging_info("Renamed %s to %s", old_filename, new_filename)
 
-    def _format_columns_sorted_numerically(
+    def _format_columns_sorted_numerically(  # pylint: disable=too-many-locals
         self, values: dict[str, Any], max_width: int = 105, max_columns: int = 4
     ) -> list[str]:
         """
@@ -212,17 +194,19 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
             return []
 
         # Sort values numerically by key
-        try:
-            # Try to sort by numeric key (int first, then float)
+        def sort_key(item: tuple[str, Any]) -> tuple[int, Union[int, float, str]]:
+            key = item[0]
             try:
-                sorted_items = sorted(values.items(), key=lambda x: int(x[0]))
+                return (0, int(key))  # sort integers and floats together
             except ValueError:
-                sorted_items = sorted(values.items(), key=lambda x: float(x[0]))
-        except ValueError:
-            # Fall back to string sorting if numeric sorting fails
-            sorted_items = sorted(values.items())
+                try:
+                    return (0, float(key))  # sort integers and floats together
+                except ValueError:
+                    return (1, str(key))  # Fall back to string sorting and sort them after
+
+        sorted_items = sorted(values.items(), key=sort_key)
 
-        # Format each key-value pair
+        # Format each key-value pair using f-strings
         formatted_items = [f"{key}: {value}" for key, value in sorted_items]
 
         if not formatted_items:
@@ -252,74 +236,96 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
 
         return result
 
-    def __extend_and_reformat_parameter_documentation_metadata(self) -> None:  # pylint: disable=too-many-branches
+    def __extend_and_reformat_parameter_documentation_metadata(self) -> None:
         for param_name, param_info in self.doc_dict.items():
-            if "fields" in param_info:
-                param_fields = param_info["fields"]
-                if "Units" in param_fields:
-                    units_list = param_fields["Units"].split("(")
-                    param_info["unit"] = units_list[0].strip()
-                    if len(units_list) > 1:
-                        param_info["unit_tooltip"] = units_list[1].strip(")").strip()
-                if "Range" in param_fields:
-                    param_info["min"] = float(param_fields["Range"].split(" ")[0].strip())
-                    param_info["max"] = float(param_fields["Range"].split(" ")[1].strip())
-                if "Calibration" in param_fields:
-                    param_info["Calibration"] = self.str_to_bool(param_fields["Calibration"].strip())
-                if "ReadOnly" in param_fields:
-                    param_info["ReadOnly"] = self.str_to_bool(param_fields["ReadOnly"].strip())
-                if "RebootRequired" in param_fields:
-                    param_info["RebootRequired"] = self.str_to_bool(param_fields["RebootRequired"].strip())
-                if "Bitmask" in param_fields:
-                    bitmask_items = param_fields["Bitmask"].split(",")
-                    param_info["Bitmask"] = {}
-                    for item in bitmask_items:
-                        key, value = item.split(":")
-                        param_info["Bitmask"][int(key.strip())] = value.strip()
-
-            if param_info.get("values"):
-                try:
-                    param_info["Values"] = {int(k): v for k, v in param_info["values"].items()}
-                except ValueError:
-                    try:
-                        param_info["Values"] = {float(k): v for k, v in param_info["values"].items()}
-                    except ValueError:
-                        logging_warning(_("Could not convert values to int or float for %s"), param_name)
-                        logging_warning(
-                            _("Parameter %s has invalid metadata. Please file a bug at %s"),
-                            param_name,
-                            "https://github.com/ArduPilot/ardupilot/issues",
-                        )
-                # print(param_info['Values'])
-
-            prefix_parts = [
-                f"{param_info['humanName']}",
-            ]
-            prefix_parts += param_info["documentation"]
-            for key, value in param_info["fields"].items():
-                if key not in {"Units", "UnitText"}:
-                    prefix_parts += split_into_lines(f"{key}: {value}", TOOLTIP_MAX_LENGTH)
-            prefix_parts += format_columns(param_info["values"], TOOLTIP_MAX_LENGTH)
-            if param_name in self.param_default_dict:
-                default_value = format(self.param_default_dict[param_name].value, ".6f").rstrip("0").rstrip(".")
-                prefix_parts += [f"Default: {default_value}"]
-            param_info["doc_tooltip"] = ("\n").join(prefix_parts)
-
-            # Create a numerically sorted version for Current Value column tooltips
-            prefix_parts_sorted = [
-                f"{param_info['humanName']}",
-            ]
-            prefix_parts_sorted += param_info["documentation"]
-            for key, value in param_info["fields"].items():
-                if key not in {"Units", "UnitText"}:
-                    prefix_parts_sorted += split_into_lines(f"{key}: {value}", TOOLTIP_MAX_LENGTH)
-            prefix_parts_sorted += self._format_columns_sorted_numerically(param_info["values"], TOOLTIP_MAX_LENGTH)
-            if param_name in self.param_default_dict:
-                default_value = format(self.param_default_dict[param_name].value, ".6f").rstrip("0").rstrip(".")
-                prefix_parts_sorted += [f"Default: {default_value}"]
-            param_info["doc_tooltip_sorted_numerically"] = ("\n").join(prefix_parts_sorted)
-
-    def read_params_from_files(self) -> dict[str, dict[str, "Par"]]:
+            self._process_parameter_fields(param_info)
+            self._process_parameter_values(param_name, param_info)
+            self._create_parameter_tooltips(param_name, param_info)
+
+    def _process_parameter_fields(self, param_info: dict[str, Any]) -> None:
+        """Process and extract parameter fields like Units, Range, etc."""
+        if "fields" not in param_info:
+            return
+
+        param_fields = param_info["fields"]
+
+        # Process Units
+        if "Units" in param_fields:
+            units_list = param_fields["Units"].split("(")
+            param_info["unit"] = units_list[0].strip()
+            if len(units_list) > 1:
+                param_info["unit_tooltip"] = units_list[1].strip(")").strip()
+
+        # Process Range
+        if "Range" in param_fields:
+            range_parts = param_fields["Range"].split(" ")
+            if len(range_parts) >= 2:
+                param_info["min"] = float(range_parts[0].strip())
+                param_info["max"] = float(range_parts[1].strip())
+
+        # Process boolean fields using dict comprehension for better performance
+        boolean_fields = ["Calibration", "ReadOnly", "RebootRequired"]
+        param_info.update(
+            {
+                field_name: self.str_to_bool(param_fields[field_name].strip())
+                for field_name in boolean_fields
+                if field_name in param_fields
+            }
+        )
+
+        # Process Bitmask using dict comprehension for better performance
+        if "Bitmask" in param_fields:
+            bitmask_items = param_fields["Bitmask"].split(",")
+            param_info["Bitmask"] = {
+                int(key.strip()): value.strip() for item in bitmask_items if ":" in item for key, value in [item.split(":", 1)]
+            }
+
+    def _process_parameter_values(self, param_name: str, param_info: dict[str, Any]) -> None:
+        """Process and convert parameter values to appropriate numeric types."""
+        if not param_info.get("values"):
+            return
+
+        try:
+            param_info["Values"] = {int(k): v for k, v in param_info["values"].items()}
+        except ValueError:
+            try:
+                param_info["Values"] = {float(k): v for k, v in param_info["values"].items()}
+            except ValueError:
+                logging_warning(_("Could not convert values to int or float for %s"), param_name)
+                logging_warning(
+                    _("Parameter %s has invalid metadata. Please file a bug at %s"),
+                    param_name,
+                    "https://github.com/ArduPilot/ardupilot/issues",
+                )
+
+    def _create_parameter_tooltips(self, param_name: str, param_info: dict[str, Any]) -> None:
+        """Create tooltip documentation for parameters."""
+        # Create common prefix parts
+        prefix_parts = [f"{param_info['humanName']}"]
+        prefix_parts += param_info["documentation"]
+
+        # Add field information (excluding Units and UnitText)
+        for key, value in param_info["fields"].items():
+            if key not in {"Units", "UnitText"}:
+                prefix_parts += split_into_lines(f"{key}: {value}", TOOLTIP_MAX_LENGTH)
+
+        # Add default value if available
+        default_suffix = []
+        if param_name in self.param_default_dict:
+            default_value = format(self.param_default_dict[param_name].value, ".6f").rstrip("0").rstrip(".")
+            default_suffix = [f"Default: {default_value}"]
+
+        # Create standard tooltip with alphabetically sorted values
+        prefix_parts_with_values = prefix_parts + format_columns(param_info["values"], TOOLTIP_MAX_LENGTH) + default_suffix
+        param_info["doc_tooltip"] = "\n".join(prefix_parts_with_values)
+
+        # Create numerically sorted tooltip for Current Value column
+        prefix_parts_with_sorted_values = (
+            prefix_parts + self._format_columns_sorted_numerically(param_info["values"], TOOLTIP_MAX_LENGTH) + default_suffix
+        )
+        param_info["doc_tooltip_sorted_numerically"] = "\n".join(prefix_parts_with_sorted_values)
+
+    def read_params_from_files(self) -> dict[str, ParDict]:
         """
         Reads intermediate parameter files from a directory and stores their contents in a dictionary.
 
@@ -328,11 +334,10 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         Files named '00_default.param' and '01_ignore_readonly.param' are ignored.
 
         Returns:
-        - Dict[str, Dict[str, 'Par']]: A dictionary with filenames as keys and as values
-                                       a dictionary with (parameter names, values) pairs.
+        - Dict[str, ParDict]: A dictionary with filenames as keys and ParDict as values.
 
         """
-        parameters: dict[str, dict[str, Par]] = {}
+        parameters: dict[str, ParDict] = {}
         if os_path.isdir(self.vehicle_dir):
             # Regular expression pattern for filenames starting with two digits followed by an underscore and ending in .param
             pattern = re_compile(r"^\d{2}_.*\.param$")
@@ -341,7 +346,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 if pattern.match(filename):
                     if filename in {"00_default.param", "01_ignore_readonly.param"}:
                         continue
-                    parameters[filename] = Par.load_param_file_into_dict(os_path.join(self.vehicle_dir, filename))
+                    parameters[filename] = ParDict.from_file(os_path.join(self.vehicle_dir, filename))
         else:
             logging_error(_("Error: %s is not a directory."), self.vehicle_dir)
         return parameters
@@ -361,13 +366,15 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
           Optional[bool]: True, False, or None if the string does not match any known boolean representation.
 
         """
-        if s.lower() == "true" or s.lower() == "yes" or s.lower() == "1":
+        # Use sets for faster O(1) lookup instead of multiple comparisons
+        lower_s = s.lower()
+        if lower_s in {"true", "yes", "1"}:
             return True
-        if s.lower() == "false" or s.lower() == "no" or s.lower() == "0":
+        if lower_s in {"false", "no", "0"}:
             return False
         return None
 
-    def export_to_param(self, params: dict[str, "Par"], filename_out: str, annotate_doc: bool = True) -> None:
+    def export_to_param(self, params: ParDict, filename_out: str, annotate_doc: bool = True) -> None:
         """
         Exports a dictionary of parameters to a .param file and optionally annotates the documentation.
 
@@ -375,12 +382,12 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         writes the string to the specified output file, and optionally updates the parameter documentation.
 
         Args:
-          params (Dict[str, 'Par']): A dictionary of parameters to export.
+          params (ParDict): A ParDict of parameters to export.
           filename_out (str): The name of the output file.
           annotate_doc (bool, optional): Whether to update the parameter documentation. Default is True.
 
         """
-        Par.export_to_param(Par.format_params(params), os_path.join(self.vehicle_dir, filename_out))
+        params.export_to_param(os_path.join(self.vehicle_dir, filename_out))
         if annotate_doc:
             update_parameter_documentation(
                 self.doc_dict, os_path.join(self.vehicle_dir, filename_out), "missionplanner", self.param_default_dict
@@ -414,68 +421,45 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         """
         ret = {}
         for params in self.file_parameters.values():
-            for param, info in params.items():
-                if info.comment:
-                    ret[param] = info.comment
+            ret.update({param: info.comment for param, info in params.items() if info.comment})
         return ret
 
-    def annotate_intermediate_comments_to_param_dict(self, param_dict: dict[str, float]) -> dict[str, "Par"]:
+    def annotate_intermediate_comments_to_param_dict(self, param_dict: dict[str, float]) -> ParDict:
         """
         Annotates comments from intermediate parameter files to a parameter value-only dictionary.
 
         This function takes a dictionary of parameters with only values and adds comments from
-        intermediate parameter files to create a new dictionary where each parameter is represented
+        intermediate parameter files to create a new ParDict where each parameter is represented
         by a 'Par' object containing both the value and the comment.
 
         Args:
           param_dict (Dict[str, float]): A dictionary of parameters with only values.
 
         Returns:
-          Dict[str, 'Par']: A dictionary of parameters with intermediate parameter file comments.
+          ParDict: A ParDict of parameters with intermediate parameter file comments.
 
         """
-        ret = {}
         ip_comments = self.__all_intermediate_parameter_file_comments()
-        for param, value in param_dict.items():
-            ret[param] = Par(float(value), ip_comments.get(param, ""))
-        return ret
+        return ParDict.from_float_dict(param_dict).annotate_with_comments(ip_comments)
 
-    def categorize_parameters(self, param: dict[str, "Par"]) -> tuple[dict[str, "Par"], dict[str, "Par"], dict[str, "Par"]]:
+    def categorize_parameters(self, param: ParDict) -> tuple[ParDict, ParDict, ParDict]:
         """
         Categorize parameters into three categories based on their default values and documentation attributes.
 
-        This method iterates through the provided dictionary of parameters and categorizes them into three groups:
+        This method iterates through the provided ParDict of parameters and categorizes them into three groups:
         - Non-default, read-only parameters
         - Non-default, writable calibrations
         - Non-default, writable non-calibrations
 
         Args:
-          param (Dict[str, 'Par']): A dictionary mapping parameter names to their 'Par' objects.
+          param (ParDict): A ParDict mapping parameter names to their 'Par' objects.
 
         Returns:
-          Tuple[Dict[str, "Par"], Dict[str, "Par"], Dict[str, "Par"]]: A tuple of three dictionaries.
-                                  Each dictionary represents one of the categories mentioned above.
+          Tuple[ParDict, ParDict, ParDict]: A tuple of three ParDict objects.
+                                  Each ParDict represents one of the categories mentioned above.
 
         """
-        non_default__read_only_params = {}
-        non_default__writable_calibrations = {}
-        non_default__writable_non_calibrations = {}
-        for param_name, param_info in param.items():
-            if param_name in self.param_default_dict and is_within_tolerance(
-                param_info.value, self.param_default_dict[param_name].value
-            ):
-                continue  # parameter has a default value, ignore it
-
-            if param_name in self.doc_dict and self.doc_dict[param_name].get("ReadOnly", False):
-                non_default__read_only_params[param_name] = param_info
-                continue
-
-            if param_name in self.doc_dict and self.doc_dict[param_name].get("Calibration", False):
-                non_default__writable_calibrations[param_name] = param_info
-                continue
-            non_default__writable_non_calibrations[param_name] = param_info
-
-        return non_default__read_only_params, non_default__writable_calibrations, non_default__writable_non_calibrations
+        return param.categorize_by_documentation(self.doc_dict, self.param_default_dict, is_within_tolerance)
 
     @staticmethod
     def get_directory_name_from_full_path(full_path: str) -> str:
@@ -538,9 +522,9 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
             for file_name in specific_files:
                 self.add_configuration_file_to_zip(zipf, file_name)
 
-            for wrote, filename in files_to_zip:
-                if wrote:
-                    self.add_configuration_file_to_zip(zipf, filename)
+            # Add conditional files using generator expression filtering
+            for filename in (filename for wrote, filename in files_to_zip if wrote):
+                self.add_configuration_file_to_zip(zipf, filename)
 
         logging_info(_("Intermediate parameter files and summary files zipped to %s"), zip_file_path)
 
@@ -741,10 +725,8 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         if (even_if_last_uploaded_filename_exists or not self.__read_last_uploaded_filename()) and (
             overwrite_existing_file or not self.vehicle_configuration_file_exists(filename)
         ):
-            Par.export_to_param(
-                Par.format_params({param: Par(float(value), "") for param, value in param_dict.items()}),
-                os_path.join(self.vehicle_dir, filename),
-            )
+            param_dict_as_par = ParDict({param: Par(float(value), "") for param, value in param_dict.items()})
+            param_dict_as_par.export_to_param(os_path.join(self.vehicle_dir, filename))
 
     def get_eval_variables(self) -> dict[str, dict[str, Any]]:
         variables = {}
@@ -773,7 +755,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         Args:
             source_param_values: Dictionary mapping parameter names to their values from the
                                 source (typically flight controller). If None, no direct updates occur.
-            existing_fc_params: List of params that exist in the FC if empty or None all parameters are+
+            existing_fc_params: List of params that exist in the FC if empty or None all parameters are
                                 assumed to exist
 
         Returns:
@@ -793,7 +775,9 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 if error_msg:
                     return error_msg
                 self.merge_forced_or_derived_parameters(param_filename, self.forced_parameters, existing_fc_params)
-                error_msg = self.compute_parameters(param_filename, step_dict, "derived", eval_variables)
+                error_msg = self.compute_parameters(
+                    param_filename, step_dict, "derived", eval_variables, ignore_fc_derived_param_warnings=True
+                )
                 if error_msg:
                     return error_msg
                 self.merge_forced_or_derived_parameters(param_filename, self.derived_parameters, existing_fc_params)
@@ -803,7 +787,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         return ""
 
     def merge_forced_or_derived_parameters(
-        self, filename: str, new_parameters: dict[str, dict[str, Par]], existing_fc_params: Optional[list[str]]
+        self, filename: str, new_parameters: dict[str, ParDict], existing_fc_params: Optional[list[str]]
     ) -> bool:
         """
         Merge forced or derived parameter values in the self.file_parameter list.
@@ -830,18 +814,17 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 self.file_parameters[filename][param_name] = param
         return at_least_one_param_changed
 
-    def write_param_default_values(self, param_default_values: dict[str, "Par"]) -> bool:
-        param_default_values = dict(sorted(param_default_values.items()))
+    def write_param_default_values(self, param_default_values: ParDict) -> bool:
+        param_default_values = ParDict(dict(sorted(param_default_values.items())))
         if self.param_default_dict != param_default_values:
             self.param_default_dict = param_default_values
             return True
         return False
 
-    def write_param_default_values_to_file(
-        self, param_default_values: dict[str, "Par"], filename: str = "00_default.param"
-    ) -> None:
+    def write_param_default_values_to_file(self, param_default_values: ParDict, filename: str = "00_default.param") -> None:
         if self.write_param_default_values(param_default_values):
-            Par.export_to_param(Par.format_params(self.param_default_dict), os_path.join(self.vehicle_dir, filename))
+            self.file_parameters[filename] = param_default_values
+            self.param_default_dict.export_to_param(os_path.join(self.vehicle_dir, filename))
 
     def get_download_url_and_local_filename(self, selected_file: str) -> tuple[str, str]:
         if (

ardupilot_methodic_configurator/backend_filesystem_configuration_steps.py

@@ -22,7 +22,7 @@ from jsonschema import validate as json_validate
 from jsonschema.exceptions import ValidationError
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.annotate_params import Par
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
 
 
 class ConfigurationSteps:
@@ -42,8 +42,8 @@ class ConfigurationSteps:
         self.configuration_steps_filename = "configuration_steps_" + vehicle_type + ".json"
         self.configuration_steps: dict[str, dict] = {}
         self.configuration_phases: dict[str, dict] = {}
-        self.forced_parameters: dict[str, dict] = {}
-        self.derived_parameters: dict[str, dict] = {}
+        self.forced_parameters: dict[str, ParDict] = {}
+        self.derived_parameters: dict[str, ParDict] = {}
         self.log_loaded_file = False
 
     def re_init(self, vehicle_dir: str, vehicle_type: str) -> None:  # pylint: disable=too-many-branches
@@ -138,7 +138,14 @@ class ConfigurationSteps:
                         parameter,
                     )
 
-    def compute_parameters(self, filename: str, file_info: dict, parameter_type: str, variables: dict) -> str:  # pylint: disable=too-many-branches
+    def compute_parameters(  # pylint: disable=too-many-branches, too-many-arguments, too-many-positional-arguments
+        self,
+        filename: str,
+        file_info: dict,
+        parameter_type: str,
+        variables: dict,
+        ignore_fc_derived_param_warnings: bool = False,
+    ) -> str:
         """
         Computes the forced or derived parameters for a given configuration file.
 
@@ -161,7 +168,8 @@ class ConfigurationSteps:
                     if parameter_type == "forced":
                         logging_error(error_msg)
                         return error_msg
-                    logging_warning(error_msg)
+                    if not ignore_fc_derived_param_warnings:
+                        logging_warning(error_msg)
                     continue
                 result = eval(str(parameter_info["New Value"]), {}, variables)  # noqa: S307 pylint: disable=eval-used
 
@@ -188,7 +196,7 @@ class ConfigurationSteps:
                         continue
 
                 if filename not in destination:
-                    destination[filename] = {}
+                    destination[filename] = ParDict()
                 change_reason = _(parameter_info["Change Reason"]) if parameter_info["Change Reason"] else ""
                 destination[filename][parameter] = Par(float(result), change_reason)
             except (SyntaxError, NameError, KeyError, StopIteration) as _e:

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -60,7 +60,7 @@ class ProgramSettings:
                 "parameter_editor": True,
             },
             "directory_selection": {
-                "template_dir": os_path.join(cls.get_templates_base_dir(), "ArduCopter", "diatone_taycan_mxc", "4.5.x-params"),
+                "template_dir": os_path.join(cls.get_templates_base_dir(), "ArduCopter", "empty_4.6.x"),
                 "new_base_dir": os_path.join(settings_directory, "vehicles"),
                 "vehicle_dir": os_path.join(settings_directory, "vehicles"),
             },