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

ardupilot_methodic_configurator/backend_filesystem.py

@@ -36,7 +36,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 +47,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 +63,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 +74,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 +123,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:
@@ -319,7 +295,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 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"]]:
+    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 +304,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 +316,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
@@ -367,7 +342,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
             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 +350,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
@@ -419,63 +394,42 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                     ret[param] = 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:
@@ -741,10 +695,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 +725,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 +745,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 +757,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 +784,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"),
             },

ardupilot_methodic_configurator/backend_flightcontroller.py

@@ -27,10 +27,10 @@ from pymavlink.dialects.v20.ardupilotmega import MAVLink_autopilot_version_messa
 from serial.serialutil import SerialException
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.argparse_check_range import CheckRange
 from ardupilot_methodic_configurator.backend_flightcontroller_info import BackendFlightcontrollerInfo
 from ardupilot_methodic_configurator.backend_mavftp import MAVFTP
+from ardupilot_methodic_configurator.data_model_par_dict import ParDict
 
 # pylint: disable=too-many-lines
 
@@ -73,7 +73,7 @@ class FlightController:  # pylint: disable=too-many-public-methods
     Attributes:
         device (str): The connection string to the flight controller.
         master (mavutil.mavlink_connection): The MAVLink connection object.
-        fc_parameters (Dict[str, float]): A dictionary of flight controller parameters.
+        fc_parameters (dict[str, float]): A dictionary of flight controller parameters.
 
     """
 
@@ -525,24 +525,24 @@ class FlightController:  # pylint: disable=too-many-public-methods
 
     def download_params(
         self, progress_callback: Union[None, Callable[[int, int], None]] = None
-    ) -> tuple[dict[str, float], dict[str, "Par"]]:
+    ) -> tuple[dict[str, float], ParDict]:
         """
         Requests all flight controller parameters from a MAVLink connection.
 
         Returns:
-            Dict[str, float]: A dictionary of flight controller parameters.
-            Dict[str, Par]: A dictionary of flight controller default parameters.
+            dict[str, float]: A dictionary of flight controller parameters.
+            ParDict: A dictionary of flight controller default parameters.
 
         """
         # FIXME this entire if statement is for testing only, remove it later pylint: disable=fixme
         if self.master is None and self.comport is not None and self.comport.device == "test":
             filename = "params.param"
             logging_warning(_("Testing active, will load all parameters from the %s file"), filename)
-            par_dict_with_comments = Par.load_param_file_into_dict(filename)
-            return {k: v.value for k, v in par_dict_with_comments.items()}, {}
+            par_dict_with_comments = ParDict.from_file(filename)
+            return {k: v.value for k, v in par_dict_with_comments.items()}, ParDict()
 
         if self.master is None:
-            return {}, {}
+            return {}, ParDict()
 
         # Check if MAVFTP is supported
         comport_device = getattr(self.comport, "device", "")
@@ -554,7 +554,7 @@ class FlightController:  # pylint: disable=too-many-public-methods
                 return param_dict, default_param_dict
 
         logging_info(_("MAVFTP is not supported by the %s flight controller, fallback to MAVLink"), comport_device)
-        return self.__download_params_via_mavlink(progress_callback), {}
+        return self.__download_params_via_mavlink(progress_callback), ParDict()
 
     def __download_params_via_mavlink(
         self, progress_callback: Union[None, Callable[[int, int], None]] = None
@@ -597,9 +597,9 @@ class FlightController:  # pylint: disable=too-many-public-methods
 
     def download_params_via_mavftp(
         self, progress_callback: Union[None, Callable[[int, int], None]] = None
-    ) -> tuple[dict[str, float], dict[str, "Par"]]:
+    ) -> tuple[dict[str, float], ParDict]:
         if self.master is None:
-            return {}, {}
+            return {}, ParDict()
         mavftp = MAVFTP(self.master, target_system=self.master.target_system, target_component=self.master.target_component)
 
         def get_params_progress_callback(completion: float) -> None:
@@ -610,18 +610,17 @@ class FlightController:  # pylint: disable=too-many-public-methods
         default_param_filename = "00_default.param"
         mavftp.cmd_getparams([complete_param_filename, default_param_filename], progress_callback=get_params_progress_callback)
         ret = mavftp.process_ftp_reply("getparams", timeout=10)
-        pdict = {}
+        pdict: dict[str, float] = {}
         # add a file sync operation to ensure the file is completely written
         time_sleep(0.3)
         if ret.error_code == 0:
             # load the parameters from the file
-            par_dict = Par.load_param_file_into_dict(complete_param_filename)
-            for name, data in par_dict.items():
-                pdict[name] = data.value
-            defdict = Par.load_param_file_into_dict(default_param_filename)
+            par_dict = ParDict.from_file(complete_param_filename)
+            pdict = {name: data.value for name, data in par_dict.items()}
+            defdict = ParDict.from_file(default_param_filename)
         else:
             ret.display_message()
-            defdict = {}
+            defdict = ParDict()
 
         return pdict, defdict
 

ardupilot_methodic_configurator/data_model_ardupilot_parameter.py

@@ -12,8 +12,7 @@ from math import inf, isfinite, isnan, nan
 from typing import Any, Optional
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.annotate_params import Par
-from ardupilot_methodic_configurator.backend_filesystem import is_within_tolerance
+from ardupilot_methodic_configurator.data_model_par_dict import Par, is_within_tolerance
 
 
 class ParameterUnchangedError(Exception):

ardupilot_methodic_configurator/data_model_configuration_step.py

@@ -17,6 +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
 
 
 class ConfigurationStepProcessor:
@@ -157,8 +158,8 @@ class ConfigurationStepProcessor:
             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, {}).get(param_name, None)
-            derived_par = self.local_filesystem.derived_parameters.get(selected_file, {}).get(param_name, None)
+            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)