ardupilot-methodic-configurator 2.0.0__tar.gz → 2.0.2__tar.gz

{ardupilot_methodic_configurator-2.0.0 → ardupilot_methodic_configurator-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ardupilot_methodic_configurator
-Version: 2.0.0
+Version: 2.0.2
 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>
@@ -50,7 +50,7 @@ License-File: LICENSES/PSF-2.0.txt
 License-File: credits/CREDITS.md
 Requires-Dist: argcomplete==3.6.2
 Requires-Dist: defusedxml==0.7.1
-Requires-Dist: jsonschema==4.24.0
+Requires-Dist: jsonschema==4.25.0
 Requires-Dist: matplotlib==3.9.4; python_version < "3.10"
 Requires-Dist: matplotlib==3.10.3; python_version >= "3.10"
 Requires-Dist: numpy==2.0.2; python_version < "3.13"
@@ -58,14 +58,14 @@ Requires-Dist: numpy==2.2.2; python_version >= "3.13"
 Requires-Dist: pillow==11.3.0
 Requires-Dist: pip_system_certs==4.0
 Requires-Dist: platformdirs==4.3.8
-Requires-Dist: pymavlink==2.4.47
+Requires-Dist: pymavlink==2.4.49
 Requires-Dist: pyserial==3.5
 Requires-Dist: requests==2.32.4
 Requires-Dist: setuptools==80.9.0
 Provides-Extra: dev
-Requires-Dist: coverage==7.9.2; extra == "dev"
+Requires-Dist: coverage==7.10.2; extra == "dev"
 Requires-Dist: mock==5.2.0; extra == "dev"
-Requires-Dist: mypy==1.16.1; extra == "dev"
+Requires-Dist: mypy==1.17.1; extra == "dev"
 Requires-Dist: pre-commit==4.2.0; extra == "dev"
 Requires-Dist: pylint==3.3.7; extra == "dev"
 Requires-Dist: pyright==1.1.403; extra == "dev"
@@ -74,15 +74,15 @@ Requires-Dist: pytest-cov==6.2.1; extra == "dev"
 Requires-Dist: pytest-md==0.2.0; extra == "dev"
 Requires-Dist: pytest-mock==3.14.1; extra == "dev"
 Requires-Dist: python-gettext==5.0; extra == "dev"
-Requires-Dist: ruff==0.12.3; extra == "dev"
+Requires-Dist: ruff==0.12.7; extra == "dev"
 Requires-Dist: types-requests==2.32.4.20250611; extra == "dev"
 Provides-Extra: scripts
 Requires-Dist: bs4; extra == "scripts"
 Provides-Extra: win-dist
 Requires-Dist: wheel==0.45.1; extra == "win-dist"
-Requires-Dist: pip==25.1.1; extra == "win-dist"
-Requires-Dist: pywin32==310; extra == "win-dist"
-Requires-Dist: pyinstaller==6.14.2; 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: packaging==25.0; extra == "win-dist"
 Dynamic: license-file
 

{ardupilot_methodic_configurator-2.0.0 → ardupilot_methodic_configurator-2.0.2}/ardupilot_methodic_configurator/AP_Motors_test_schema.json

@@ -39,7 +39,7 @@
           "description": "Human-readable frame class name",
           "enum": [
             "QUAD",
-            "HEXA", 
+            "HEXA",
             "OCTA",
             "OCTAQUAD",
             "Y6",

{ardupilot_methodic_configurator-2.0.0 → ardupilot_methodic_configurator-2.0.2}/ardupilot_methodic_configurator/__init__.py

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

ardupilot_methodic_configurator-2.0.2/ardupilot_methodic_configurator/ardupilot_parameter.py

@@ -0,0 +1,443 @@
+"""
+ArduPilot parameter domain model.
+
+This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+
+SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
+
+SPDX-License-Identifier: GPL-3.0-or-later
+"""
+
+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
+
+
+class ArduPilotParameter:  # pylint: disable=too-many-instance-attributes, too-many-public-methods
+    """Domain model representing an ArduPilot parameter with all its attributes."""
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        name: str,
+        par_obj: Par,
+        metadata: Optional[dict[str, Any]] = None,
+        default_par: Optional[Par] = None,
+        fc_value: Optional[float] = None,
+        forced_par: Optional[Par] = None,
+        derived_par: Optional[Par] = None,
+    ) -> None:
+        """
+        Initialize the parameter with all its attributes.
+
+        Args:
+            name: Name of the parameter
+            par_obj: Par object containing value and comment
+            metadata: Dictionary of parameter metadata (from pdef.xml files)
+            default_par: Default parameter object for comparison
+            fc_value: Value from the flight controller, if connected
+            forced_par: Parameter object containing forced value and change reason
+            derived_par: Parameter object containing derived value and change reason
+
+        """
+        self._name = name
+        self._metadata = metadata or {}
+        self._default_value = default_par.value if default_par else None
+        self._fc_value = fc_value
+
+        forced_value = forced_par.value if forced_par is not None else None
+        forced_reason = forced_par.comment if forced_par is not None else None
+        derived_value = derived_par.value if derived_par is not None else None
+        derived_reason = derived_par.comment if derived_par is not None else None
+        self._is_forced = forced_value is not None and forced_value not in (nan, +inf, -inf)
+        self._is_derived = derived_value is not None and derived_value not in (nan, +inf, -inf)
+
+        # these are the values read from file, not the new values
+        self._value_on_file = par_obj.value
+        self._change_reason_on_file = par_obj.comment or ""
+
+        # new value and change reason to be sent to the flight controller and/or saved to file
+        if self._is_forced and forced_value is not None:  # second condition is redundant, but keeps linters happy
+            self._new_value = forced_value
+            self._change_reason = forced_reason or ""
+        elif self._is_derived and derived_value is not None:  # second condition is redundant, but keeps linters happy
+            self._new_value = float(derived_value)
+            self._change_reason = derived_reason or ""
+        else:
+            self._new_value = par_obj.value
+            self._change_reason = par_obj.comment or ""
+
+    @property
+    def name(self) -> str:
+        """Return this parameter name."""
+        return self._name
+
+    @property
+    def is_calibration(self) -> bool:
+        """Return True if this is a calibration parameter."""
+        return bool(self._metadata.get("Calibration", False))
+
+    @property
+    def is_readonly(self) -> bool:
+        """Return True if this is a readonly parameter."""
+        return bool(self._metadata.get("ReadOnly", False))
+
+    @property
+    def is_bitmask(self) -> bool:
+        """Return True if this parameter uses a bitmask representation."""
+        return "Bitmask" in self._metadata
+
+    @property
+    def is_forced(self) -> bool:
+        """Return True if this parameter is forced from the configuration step."""
+        return self._is_forced
+
+    @property
+    def is_derived(self) -> bool:
+        """Return True if this parameter value is derived from component editor information."""
+        return self._is_derived
+
+    @property
+    def is_multiple_choice(self) -> bool:
+        """Return True if this parameter uses a multiple choice representation."""
+        # these parameters do have choices defined in their metadata, the handful of discrete choices
+        #  is limitative and most usecases require the use of a continuous range instead
+        multiple_choice_blacklist = {
+            "MOT_SPIN_ARM",
+            "MOT_SPIN_MAX",
+            "MOT_SPIN_MIN",
+            "MOT_THST_EXPO",
+            "ATC_ACCEL_P_MAX",
+            "ATC_ACCEL_R_MAX",
+            "ATC_ACCEL_Y_MAX",
+        }
+        return (
+            self.choices_dict is not None
+            and len(self.choices_dict) > 0
+            and self.is_in_values_dict
+            and self._name not in multiple_choice_blacklist
+        )
+
+    @property
+    def is_editable(self) -> bool:
+        """Return True if the parameter can be edited, False otherwise."""
+        return not (self._is_forced or self._is_derived or self.is_readonly)
+
+    @property
+    def has_fc_value(self) -> bool:
+        """Return True if there is a flight controller value for this parameter."""
+        return self._fc_value is not None
+
+    @property
+    def fc_value_equals_default_value(self) -> bool:
+        """Return True if the flight controller value equals the default value."""
+        return (
+            self._default_value is not None
+            and self._fc_value is not None
+            and (
+                self._fc_value == self._default_value
+                if self.is_bitmask or self.is_multiple_choice
+                else is_within_tolerance(self._fc_value, self._default_value)
+            )
+        )
+
+    @property
+    def new_value_equals_default_value(self) -> bool:
+        """Return True if the new parameter value equals the default value."""
+        return self._default_value is not None and (
+            self._new_value == self._default_value
+            if self.is_bitmask or self.is_multiple_choice
+            else is_within_tolerance(self._new_value, self._default_value)
+        )
+
+    @property
+    def is_different_from_fc(self) -> bool:
+        """Return True if the new parameter value is different from the flight controller value."""
+        return self._fc_value is not None and (
+            self._new_value != self._fc_value
+            if self.is_bitmask or self.is_multiple_choice
+            else not is_within_tolerance(self._new_value, self._fc_value)
+        )
+
+    @property
+    def is_dirty(self) -> bool:
+        """Return True if this parameter has unsaved changes."""
+        value_dirty = (
+            self._new_value != self._value_on_file
+            if self.is_bitmask or self.is_multiple_choice
+            else is_within_tolerance(self._new_value, self._value_on_file)
+        )
+        return value_dirty or self._change_reason != self._change_reason_on_file
+
+    @property
+    def choices_dict(self) -> dict[str, str]:
+        """Return the multiple choices dictionary for this parameter."""
+        return dict[str, str](self._metadata.get("values", {}))
+
+    @property
+    def bitmask_dict(self) -> dict[int, str]:
+        """Return the bitmask dictionary for this parameter."""
+        return dict[int, str](self._metadata.get("Bitmask", {}))
+
+    @property
+    def min_value(self) -> Optional[float]:
+        """Return the minimum allowed value for this parameter."""
+        min_val = self._metadata.get("min", None)
+        return float(min_val) if min_val is not None else None
+
+    @property
+    def max_value(self) -> Optional[float]:
+        """Return the maximum allowed value for this parameter."""
+        max_val = self._metadata.get("max", None)
+        return float(max_val) if max_val is not None else None
+
+    @property
+    def fc_value_as_string(self) -> str:
+        """Return the flight controller value as a formatted string."""
+        if self._fc_value is None:
+            return _("N/A")
+        return format(self._fc_value, ".6f").rstrip("0").rstrip(".")
+
+    @property
+    def value_as_string(self) -> str:
+        """Return the parameter value as a formatted string."""
+        return format(self._new_value, ".6f").rstrip("0").rstrip(".")
+
+    @property
+    def is_in_values_dict(self) -> bool:
+        """Return True if the new value is in the values dictionary."""
+        return bool(self.choices_dict and self.value_as_string in self.choices_dict)
+
+    @property
+    def tooltip_fc_value(self) -> str:
+        """Return the numerically sorted documentation tooltip for this parameter."""
+        return str(self._metadata.get("doc_tooltip_sorted_numerically", self.tooltip_new_value))
+
+    @property
+    def tooltip_new_value(self) -> str:
+        """Return the documentation tooltip for this parameter."""
+        return str(self._metadata.get("doc_tooltip", _("No documentation available in apm.pdef.xml for this parameter")))
+
+    @property
+    def tooltip_unit(self) -> str:
+        """Return the unit tooltip for this parameter."""
+        return str(self._metadata.get("unit_tooltip", _("No documentation available in apm.pdef.xml for this parameter")))
+
+    @property
+    def tooltip_change_reason(self) -> str:
+        """Return the tooltip for the reason why this parameter should change."""
+        msg = _("Reason why {param_name} should change to {value}")
+        return msg.format(param_name=self._name, value=self._new_value)
+
+    @property
+    def unit(self) -> str:
+        """Return the unit of this parameter."""
+        return str(self._metadata.get("unit", ""))
+
+    @property
+    def change_reason(self) -> str:
+        """Return the change reason string for this parameter."""
+        return self._change_reason
+
+    def get_selected_value_from_dict(self) -> Optional[str]:
+        """Return the string representation from the values dictionary for the new value."""
+        if self.is_in_values_dict:
+            return self.choices_dict.get(self.value_as_string)
+        return None
+
+    def is_invalid_number(self, new_value: float) -> str:
+        """Return an error message if the new value is an invalid number."""
+        if not isfinite(new_value) or isnan(new_value):
+            return _("The value for {param_name} must be a finite number.").format(param_name=self._name)
+        return ""
+
+    def is_above_limit(self, value: Optional[float] = None) -> str:
+        """Return an error message if the value is above the limit for this parameter."""
+        new_value = self._new_value if value is None else value
+        if self.max_value is not None and new_value > self.max_value:
+            return _("The value for {param_name} ({value}) should be smaller than {max_val}\n").format(
+                param_name=self._name, value=new_value, max_val=self.max_value
+            )
+        return ""
+
+    def is_below_limit(self, value: Optional[float] = None) -> str:
+        """Return an error message if the value is below the limit for this parameter."""
+        new_value = self._new_value if value is None else value
+        if self.min_value is not None and new_value < self.min_value:
+            return _("The value for {param_name} ({value}) should be greater than {min_val}\n").format(
+                param_name=self._name, value=new_value, min_val=self.min_value
+            )
+        return ""
+
+    def fc_value_is_above_limit(self) -> str:
+        """Return an error message if the FC value is above the limit for this parameter."""
+        return self.is_above_limit(self._fc_value) if self._fc_value is not None else ""
+
+    def fc_value_is_below_limit(self) -> str:
+        """Return an error message if the RC value is below the limit for this parameter."""
+        return self.is_below_limit(self._fc_value) if self._fc_value is not None else ""
+
+    def set_new_value(self, value: float) -> bool:
+        """
+        Set the new parameter value and return whether it changed.
+
+        Args:
+            value: The new value to set
+
+        Returns:
+            True if the new value was changed, False otherwise
+
+        """
+        if self._is_forced or self._is_derived:
+            return False
+
+        if (self.is_bitmask or self.is_multiple_choice) and value == self._new_value:
+            return False
+
+        if not (self.is_bitmask or self.is_multiple_choice) and is_within_tolerance(self._new_value, value):
+            return False
+
+        self._new_value = value
+        return True
+
+    def set_change_reason(self, change_reason: str) -> bool:
+        """
+        Set the parameter change_reason and return whether it changed.
+
+        Args:
+            change_reason: The new change_reason to set
+
+        Returns:
+            True if the change_reason was changed, False otherwise
+
+        """
+        if self._is_forced or self._is_derived:
+            return False
+
+        if change_reason == self._change_reason or (change_reason == "" and self._change_reason is None):
+            return False
+
+        self._change_reason = change_reason
+        return True
+
+
+class BitmaskHelper:
+    """Helper class for working with ArduPilot parameter bitmasks."""
+
+    @staticmethod
+    def get_checked_keys(value: int, bitmask_dict: dict[int, str]) -> set[int]:
+        """
+        Convert a decimal value to a set of checked bit keys.
+
+        Args:
+            value: The decimal value to convert
+            bitmask_dict: Dictionary mapping bit positions to descriptions
+
+        Returns:
+            Set of keys (bit positions) that are set in the value
+
+        """
+        return {key for key in bitmask_dict if (value >> key) & 1}
+
+    @staticmethod
+    def get_value_from_keys(checked_keys: set[int]) -> int:
+        """
+        Convert a list of checked bit keys to a decimal value.
+
+        Args:
+            checked_keys: List of bit positions that are set
+
+        Returns:
+            The decimal value representing the bits set
+
+        """
+        return sum(1 << key for key in checked_keys)
+
+
+class ConnectionRenamer:
+    """
+    Utility class to handle renaming parameters based on connection prefixes.
+
+    This captures the logic for renaming parameters when connection types change,
+    particularly handling special cases like CAN bus connections.
+    """
+
+    @staticmethod
+    def generate_renames(parameters: list[str], new_connection_prefix: str) -> dict[str, str]:
+        """
+        Generate a dictionary of parameter renames based on a new connection prefix.
+
+        Args:
+            parameters: List of parameter names to potentially rename
+            new_connection_prefix: The new prefix to apply (like "CAN2")
+
+        Returns:
+            Dictionary mapping old parameter names to new parameter names
+
+        """
+        renames: dict[str, str] = {}
+
+        # Extract the type and number from the new connection prefix
+        if len(new_connection_prefix) < 2:
+            return renames
+
+        new_type = new_connection_prefix[:-1]  # e.g., "CAN" from "CAN2"
+        new_number = new_connection_prefix[-1]  # e.g., "2" from "CAN2"
+
+        for param_name in parameters:
+            new_prefix = new_connection_prefix
+            old_prefix = param_name.split("_")[0]
+            if new_type == "CAN" and "CAN_P" in param_name:
+                old_prefix = param_name.split("_")[0] + "_" + param_name.split("_")[1]
+                new_prefix = "CAN_P" + new_number
+            if new_type == "CAN" and "CAN_D" in param_name:
+                old_prefix = param_name.split("_")[0] + "_" + param_name.split("_")[1]
+                new_prefix = "CAN_D" + new_number
+
+            if new_type in old_prefix:
+                renames[param_name] = param_name.replace(old_prefix, new_prefix)
+
+        return renames
+
+    @staticmethod
+    def apply_renames(
+        parameters: dict[str, Any], new_connection_prefix: str, variables: Optional[dict[str, Any]] = None
+    ) -> tuple[set[str], list[tuple[str, str]]]:
+        """
+        Apply connection prefix renames to a parameter dictionary.
+
+        Args:
+            parameters: Dictionary of parameter objects to rename, it will modify it
+            new_connection_prefix: The new prefix to apply
+            variables: Optional dictionary of variables for evaluation
+
+        Returns:
+            Tuple containing:
+            - Set of duplicated parameter names that got removed
+            - List of (old_name, new_name) pairs that were renamed
+
+        """
+        if variables:
+            # If variables provided, evaluate the new_connection_prefix
+            new_connection_prefix = eval(str(new_connection_prefix), {}, variables)  # noqa: S307 pylint: disable=eval-used
+
+        # Generate the rename mapping
+        renames = ConnectionRenamer.generate_renames(list(parameters.keys()), new_connection_prefix)
+
+        # Track unique new names and actual renames performed
+        new_names = set()
+        duplicates = set()
+        renamed_pairs = []
+        for old_name, new_name in renames.items():
+            if new_name in new_names:
+                parameters.pop(old_name)
+                duplicates.add(old_name)
+            else:
+                new_names.add(new_name)
+                if new_name != old_name:
+                    parameters[new_name] = parameters.pop(old_name)
+                    renamed_pairs.append((old_name, new_name))
+
+        return duplicates, renamed_pairs

{ardupilot_methodic_configurator-2.0.0 → ardupilot_methodic_configurator-2.0.2}/ardupilot_methodic_configurator/backend_filesystem.py

@@ -115,8 +115,8 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
 
         if blank_component_data:
             self.wipe_component_info()
-            if self.vehicle_components and "Components" in self.vehicle_components:
-                self.save_vehicle_components_json_data(self.vehicle_components, self.vehicle_dir)
+            if self.vehicle_components_fs.data and "Components" in self.vehicle_components_fs.data:
+                self.save_vehicle_components_json_data(self.vehicle_components_fs.data, self.vehicle_dir)
 
         if not self.fw_version:
             self.fw_version = self.get_fc_fw_version_from_vehicle_components_json()
@@ -159,7 +159,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
             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_json_filename in vehicle_configuration_files and any(
+            if self.vehicle_components_fs.json_filename in vehicle_configuration_files and any(
                 pattern.match(f) for f in vehicle_configuration_files
             ):
                 return True
@@ -524,7 +524,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 "00_default.param",
                 "apm.pdef.xml",
                 self.configuration_steps_filename,
-                self.vehicle_components_json_filename,
+                self.vehicle_components_fs.json_filename,
                 "vehicle.jpg",
                 "last_uploaded_filename.txt",
                 "tempcal_gyro.png",
@@ -700,8 +700,12 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
 
     def get_eval_variables(self) -> dict[str, dict[str, Any]]:
         variables = {}
-        if hasattr(self, "vehicle_components") and self.vehicle_components and "Components" in self.vehicle_components:
-            variables["vehicle_components"] = self.vehicle_components["Components"]
+        if (
+            hasattr(self, "vehicle_components_fs")
+            and self.vehicle_components_fs.data
+            and "Components" in self.vehicle_components_fs.data
+        ):
+            variables["vehicle_components"] = self.vehicle_components_fs.data["Components"]
         if hasattr(self, "doc_dict") and self.doc_dict:
             variables["doc_dict"] = self.doc_dict
         return variables

{ardupilot_methodic_configurator-2.0.0 → ardupilot_methodic_configurator-2.0.2}/ardupilot_methodic_configurator/backend_filesystem_json_with_schema.py

@@ -9,7 +9,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 """
 
 from json import JSONDecodeError
-from json import dump as json_dump
+from json import dumps as json_dumps
 from json import load as json_load
 
 # from logging import warning as logging_warning
@@ -125,7 +125,10 @@ class FilesystemJSONWithSchema:
         filepath = os_path.join(data_dir, self.json_filename)
         try:
             with open(filepath, "w", encoding="utf-8", newline="\n") as file:
-                json_dump(data, file, indent=4)
+                json_str = json_dumps(data, indent=4)
+                # Strip the last newline to avoid double newlines
+                # This is to ensure compatibility with pre-commit's end-of-file-fixer
+                file.write(json_str.rstrip("\n") + "\n")
         except FileNotFoundError:
             msg = _("Directory '{}' not found").format(data_dir)
             logging_error(msg)