ardupilot-methodic-configurator 1.5.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

ardupilot_methodic_configurator/data_model_vehicle_components.py

@@ -8,14 +8,18 @@ SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 SPDX-License-Identifier: GPL-3.0-or-later
 """
 
+from ardupilot_methodic_configurator.data_model_vehicle_components_display import ComponentDataModelDisplay
 from ardupilot_methodic_configurator.data_model_vehicle_components_import import ComponentDataModelImport
 from ardupilot_methodic_configurator.data_model_vehicle_components_templates import ComponentDataModelTemplates
 from ardupilot_methodic_configurator.data_model_vehicle_components_validation import ComponentDataModelValidation
 
 
-class ComponentDataModel(ComponentDataModelValidation, ComponentDataModelImport, ComponentDataModelTemplates):
+class ComponentDataModel(
+    ComponentDataModelValidation, ComponentDataModelImport, ComponentDataModelTemplates, ComponentDataModelDisplay
+):
     """
     Handle vehicle component data operations.
 
-    Combines base data model functionality with FC data import, component template handling and data validation.
+    Combines base data model functionality with FC data import,
+    component template handling, display logic, and data validation.
     """

ardupilot_methodic_configurator/data_model_vehicle_components_base.py

@@ -16,12 +16,12 @@ from typing import Any, Optional, Union
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.battery_cell_voltages import BatteryCell
+from ardupilot_methodic_configurator.data_model_vehicle_components_json_schema import VehicleComponentsJsonSchema
 
 # Type aliases to improve code readability
 ComponentPath = tuple[str, ...]
 ComponentData = dict[str, Any]
 ComponentValue = Union[str, int, float]
-ValidationRulePath = tuple[str, str, str]  # Exactly 3 elements for validation rules
 
 
 class ComponentDataModelBase:
@@ -31,12 +31,15 @@ class ComponentDataModelBase:
     This improves testability by isolating data operations.
     """
 
-    def __init__(self, initial_data: ComponentData, component_datatypes: dict[str, Any]) -> None:
+    def __init__(
+        self, initial_data: ComponentData, component_datatypes: dict[str, Any], schema: VehicleComponentsJsonSchema
+    ) -> None:
         self._data: ComponentData = initial_data if initial_data else {"Components": {}, "Format version": 1}
         self._battery_chemistry: str = ""
-        self._possible_choices: dict[ValidationRulePath, tuple[str, ...]] = {}
+        self._possible_choices: dict[ComponentPath, tuple[str, ...]] = {}
         self._mot_pwm_types: tuple[str, ...] = ()
         self._component_datatypes: dict[str, Any] = component_datatypes
+        self.schema: VehicleComponentsJsonSchema = schema
 
     def get_component_data(self) -> ComponentData:
         """
@@ -200,68 +203,92 @@ class ComponentDataModelBase:
         self.init_possible_choices(doc_dict)
         self.init_battery_chemistry()
 
-    def update_json_structure(self) -> None:  # pylint: disable=too-many-branches
+    def update_json_structure(self) -> None:
         """
         Update the data structure to ensure all required fields are present.
 
         Used to update old JSON files to the latest format.
         """
-        # Get current data
-        data = self._data
-
-        # Ensure the format version is set.
-        if "Format version" not in data:
-            data["Format version"] = 1
-
-        # To update old JSON files that do not have these new fields
-        if "Components" not in data:
-            data["Components"] = {}
-
-        if "Battery" not in data["Components"]:
-            data["Components"]["Battery"] = {}
-
-        if "Specifications" not in data["Components"]["Battery"]:
-            data["Components"]["Battery"]["Specifications"] = {}
-
-        if "Chemistry" not in data["Components"]["Battery"]["Specifications"]:
-            data["Components"]["Battery"]["Specifications"]["Chemistry"] = "Lipo"
-
-        if "Capacity mAh" not in data["Components"]["Battery"]["Specifications"]:
-            data["Components"]["Battery"]["Specifications"]["Capacity mAh"] = 0
-
-        # To update old JSON files that do not have these new "Frame.Specifications.TOW * Kg" fields
-        if "Frame" not in data["Components"]:
-            data["Components"]["Frame"] = {}
+        # Define the default structure with all required fields
+        default_structure = {
+            "Format version": 1,
+            "Program version": __version__,
+            "Components": {
+                "Battery": {
+                    "Specifications": {
+                        "Chemistry": "Lipo",
+                        "Capacity mAh": 0,
+                    }
+                },
+                "Frame": {
+                    "Specifications": {
+                        "TOW min Kg": 1,
+                        "TOW max Kg": 1,
+                    }
+                },
+                "Flight Controller": {
+                    "Product": {},
+                    "Firmware": {},
+                    "Specifications": {"MCU Series": "Unknown"},
+                    "Notes": "",
+                },
+            },
+        }
+
+        # Handle legacy field renaming before merging
+        if "GNSS receiver" in self._data.get("Components", {}):
+            components = self._data.setdefault("Components", {})
+            components["GNSS Receiver"] = components.pop("GNSS receiver")
+
+        # Handle legacy battery monitor protocol migration for protocols that don't need hardware connections
+        # This is a local import to avoid a circular import dependency
+        from ardupilot_methodic_configurator.data_model_vehicle_components_validation import (  # pylint: disable=import-outside-toplevel, cyclic-import # noqa: PLC0415
+            BATT_MONITOR_CONNECTION,
+            OTHER_PORTS,
+        )
 
-        if "Specifications" not in data["Components"]["Frame"]:
-            data["Components"]["Frame"]["Specifications"] = {}
+        # Calculate protocols that use OTHER_PORTS (don't require specific hardware connections)
+        battmon_other_protocols = {
+            str(value["protocol"]) for value in BATT_MONITOR_CONNECTION.values() if value.get("type") == OTHER_PORTS
+        }
+        battery_monitor_protocol = (
+            self._data.get("Components", {}).get("Battery Monitor", {}).get("FC Connection", {}).get("Protocol")
+        )
+        if battery_monitor_protocol in battmon_other_protocols:
+            # These protocols don't require specific hardware connections, so we can safely migrate them
+            battery_monitor = self._data.setdefault("Components", {}).setdefault("Battery Monitor", {})
+            battery_monitor.setdefault("FC Connection", {})["Type"] = "other"
 
-        if "TOW min Kg" not in data["Components"]["Frame"]["Specifications"]:
-            data["Components"]["Frame"]["Specifications"]["TOW min Kg"] = 1
+        # Merge existing data onto default structure (preserves existing values)
+        self._data = self._deep_merge_dicts(default_structure, self._data)
+        self._data["Program version"] = __version__
 
-        if "TOW max Kg" not in data["Components"]["Frame"]["Specifications"]:
-            data["Components"]["Frame"]["Specifications"]["TOW max Kg"] = 1
+    def _deep_merge_dicts(self, default: dict[str, Any], existing: dict[str, Any]) -> dict[str, Any]:
+        """
+        Deep merge two dictionaries, preserving existing values and key order.
 
-        # Older versions used receiver instead of Receiver, rename it for consistency with other fields
-        if "GNSS receiver" in data["Components"]:
-            data["Components"]["GNSS Receiver"] = data["Components"].pop("GNSS receiver")
+        Args:
+            default: Default structure with fallback values
+            existing: Existing data to preserve
 
-        data["Program version"] = __version__
+        Returns:
+            Merged dictionary with existing values taking precedence and preserving existing key order
 
-        # To update old JSON files that do not have this new "Flight Controller.Specifications.MCU Series" field
-        if "Flight Controller" not in data["Components"]:
-            data["Components"]["Flight Controller"] = {}
+        """
+        # Start with existing dictionary to preserve its key order
+        result = existing.copy()
 
-        if "Specifications" not in data["Components"]["Flight Controller"]:
-            fc_data = data["Components"]["Flight Controller"]
-            data["Components"]["Flight Controller"] = {
-                "Product": fc_data.get("Product", {}),
-                "Firmware": fc_data.get("Firmware", {}),
-                "Specifications": {"MCU Series": "Unknown"},
-                "Notes": fc_data.get("Notes", ""),
-            }
+        # Add any missing keys from the default structure
+        for key, value in default.items():
+            if key not in result:
+                # Key doesn't exist in existing data, add it from default
+                result[key] = value
+            elif isinstance(result[key], dict) and isinstance(value, dict):
+                # Both are dictionaries, recursively merge them
+                result[key] = self._deep_merge_dicts(value, result[key])
+            # If key exists in result but isn't a dict, keep the existing value (no change needed)
 
-        self._data = data
+        return result
 
     def init_battery_chemistry(self) -> None:
         self._battery_chemistry = (
@@ -275,6 +302,6 @@ class ComponentDataModelBase:
         """Initialize possible choices for validation rules."""
         # this method should be implemented in the ComponentDataModelValidation mixedin
 
-    def get_combobox_values_for_path(self, path: ValidationRulePath) -> tuple[str, ...]:
+    def get_combobox_values_for_path(self, path: ComponentPath) -> tuple[str, ...]:
         """Get valid combobox values for a given path."""
         return self._possible_choices.get(path, ())

ardupilot_methodic_configurator/data_model_vehicle_components_display.py

@@ -0,0 +1,160 @@
+"""
+Data model for vehicle component display logic.
+
+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 typing import Union
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.data_model_vehicle_components_base import (
+    ComponentDataModelBase,
+    ComponentPath,
+)
+
+
+class ComponentDataModelDisplay(ComponentDataModelBase):
+    """
+    Business logic for determining component display rules and configuration.
+
+    This class separates the data processing logic from UI concerns,
+    improving testability and maintainability.
+    """
+
+    def should_display_in_simple_mode(  # pylint: disable=too-many-branches
+        self, key: str, value: dict, path: list[str], complexity_mode: str
+    ) -> bool:
+        """
+        Determine if a component should be displayed in simple mode.
+
+        In simple mode, only show components that have at least one non-optional parameter.
+
+        Args:
+            key (str): The component key
+            value (dict): The component value
+            path (list): The path to the component
+            complexity_mode (str): Current complexity mode ("simple" or "normal")
+
+        Returns:
+            bool: True if the component should be displayed, False otherwise
+
+        """
+        # If not in simple mode, always display the component
+        if complexity_mode != "simple":
+            return True
+
+        # Top-level components need special handling
+        if not path and key in self.get_all_components():
+            # Check if this component has any non-optional parameters
+            ret = False
+            for sub_key, sub_value in value.items():
+                if isinstance(sub_value, dict):
+                    # For nested dictionaries, recursively check
+                    if self.should_display_in_simple_mode(sub_key, sub_value, [*path, key], complexity_mode):
+                        ret = True
+                        break
+                else:
+                    # For leaf nodes, check if they are optional
+                    current_path = (*path, key, sub_key)
+                    _, is_optional = self.schema.get_component_property_description(current_path)
+                    if not is_optional:
+                        ret = True
+                        break
+            return ret
+
+        # For non-top-level components or leaf nodes
+        if isinstance(value, dict):
+            # Check if this component has any non-optional parameters
+            for sub_key, sub_value in value.items():
+                current_path = (*path, key, sub_key)
+                if isinstance(sub_value, dict):
+                    if self.should_display_in_simple_mode(sub_key, sub_value, [*path, key], complexity_mode):
+                        return True
+                else:
+                    _, is_optional = self.schema.get_component_property_description(current_path)
+                    if not is_optional:
+                        return True
+
+        return False
+
+    def should_display_leaf_in_simple_mode(self, path: ComponentPath, complexity_mode: str) -> bool:
+        """
+        Determine if a leaf component should be displayed in simple mode.
+
+        Args:
+            path: The component path
+            complexity_mode: Current complexity mode ("simple" or "normal")
+
+        Returns:
+            bool: True if the component should be displayed, False otherwise
+
+        """
+        if complexity_mode != "simple":
+            return True
+
+        _, is_optional = self.schema.get_component_property_description(path)
+        return not is_optional
+
+    def prepare_non_leaf_widget_config(self, key: str, value: dict, path: list[str]) -> dict:
+        """
+        Prepare configuration for non-leaf widget creation. Pure function for easy testing.
+
+        Args:
+            key: Component key
+            value: Component value dictionary
+            path: Path to the component
+
+        Returns:
+            Dictionary with widget configuration data
+
+        """
+        is_toplevel = len(path) == 0  # More explicit than checking parent type
+        current_path = (*path, key)
+        description, is_optional = self.schema.get_component_property_description(current_path)
+        description = _(description) if description else ""
+
+        # Enhance tooltip for optional fields
+        if is_optional and description:
+            description += _("\nThis is optional and can be left blank")
+
+        return {
+            "key": key,
+            "value": value,
+            "path": current_path,
+            "description": description,
+            "is_optional": is_optional,
+            "is_toplevel": is_toplevel,
+        }
+
+    def prepare_leaf_widget_config(self, key: str, value: Union[str, float], path: list[str]) -> dict:
+        """
+        Prepare configuration for leaf widget creation. Pure function for easy testing.
+
+        Args:
+            key: Component key
+            value: Component value
+            path: Path to the component
+
+        Returns:
+            Dictionary with widget configuration data
+
+        """
+        component_path = (*path, key)
+        description, is_optional = self.schema.get_component_property_description(component_path)
+        description = _(description) if description else ""
+
+        # Enhance tooltip for optional fields
+        if is_optional and description:
+            description += _("\nThis is optional and can be left blank")
+
+        return {
+            "key": key,
+            "value": value,
+            "path": component_path,
+            "description": description,
+            "is_optional": is_optional,
+        }

ardupilot_methodic_configurator/data_model_vehicle_components_import.py

@@ -11,6 +11,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 # from logging import debug as logging_debug
 from logging import error as logging_error
 from math import log2
+from typing import Any
 
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.data_model_vehicle_components_base import ComponentDataModelBase
@@ -57,7 +58,9 @@ class ComponentDataModelImport(ComponentDataModelBase):
         logging_error(_("No values found for %s in the metadata"), param_name)
         return fallbacks
 
-    def _verify_dict_is_uptodate(self, doc: dict, dict_to_check: dict, doc_key: str, doc_dict: str) -> bool:
+    def _verify_dict_is_uptodate(
+        self, doc: dict[str, Any], dict_to_check: dict[str, dict[str, Any]], doc_key: str, doc_dict: str
+    ) -> bool:
         """
         Verify that a dictionary is up-to-date with the apm.pdef.xml documentation metadata.
 
@@ -80,8 +83,8 @@ class ComponentDataModelImport(ComponentDataModelBase):
 
     def process_fc_parameters(
         self,
-        fc_parameters: dict,
-        doc: dict,
+        fc_parameters: dict[str, Any],
+        doc: dict[str, Any],
     ) -> None:
         """
         Process flight controller parameters and update the data model accordingly.
@@ -214,7 +217,7 @@ class ComponentDataModelImport(ComponentDataModelBase):
 
         return esc >= 2
 
-    def _set_esc_type_from_fc_parameters(self, fc_parameters: dict, doc: dict) -> None:
+    def _set_esc_type_from_fc_parameters(self, fc_parameters: dict[str, Any], doc: dict[str, Any]) -> None:
         """Process ESC parameters and update the data model."""
         mot_pwm_type = fc_parameters.get("MOT_PWM_TYPE", 0)
         try:
@@ -240,7 +243,7 @@ class ComponentDataModelImport(ComponentDataModelBase):
             protocol = str(MOT_PWM_TYPE_DICT[str(mot_pwm_type)]["protocol"])
             self.set_component_value(("ESC", "FC Connection", "Protocol"), protocol)
 
-    def _set_battery_type_from_fc_parameters(self, fc_parameters: dict) -> None:
+    def _set_battery_type_from_fc_parameters(self, fc_parameters: dict[str, Any]) -> None:
         """Process battery monitor parameters and update the data model."""
         if "BATT_MONITOR" in fc_parameters:
             try:
@@ -258,7 +261,7 @@ class ComponentDataModelImport(ComponentDataModelBase):
             except (ValueError, KeyError, TypeError) as e:
                 logging_error(_("Error processing BATT_MONITOR parameter: %s"), str(e))
 
-    def _set_motor_poles_from_fc_parameters(self, fc_parameters: dict) -> None:
+    def _set_motor_poles_from_fc_parameters(self, fc_parameters: dict[str, Any]) -> None:
         """Process motor parameters and update the data model."""
         if "MOT_PWM_TYPE" in fc_parameters:
             mot_pwm_type_str = str(fc_parameters["MOT_PWM_TYPE"])