ardupilot-methodic-configurator 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

ardupilot_methodic_configurator/__init__.py

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

ardupilot_methodic_configurator/__main__.py

@@ -2,7 +2,14 @@
 # PYTHON_ARGCOMPLETE_OK
 
 """
-The main application file. calls four sub-applications.
+The main application file.
+
+Calls five sub-applications in sequence:
+  1. Check for software updates
+  2. Connect to the flight controller and read the parameters
+  3. Select the vehicle directory
+  4. Component and connection editor
+  5. Parameter editor and uploader
 
 This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
 
@@ -28,12 +35,12 @@ from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import show_error_message
 from ardupilot_methodic_configurator.frontend_tkinter_component_editor import ComponentEditorWindow
 from ardupilot_methodic_configurator.frontend_tkinter_connection_selection import ConnectionSelectionWindow
 from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWindow
 from ardupilot_methodic_configurator.frontend_tkinter_flightcontroller_info import FlightControllerInfoWindow
 from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor import ParameterEditorWindow
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_error_message
 from ardupilot_methodic_configurator.middleware_software_updates import UpdateManager, check_for_software_updates
 
 
@@ -59,11 +66,11 @@ def create_argument_parser() -> argparse.ArgumentParser:
             "The process gets repeated for each intermediate parameter file."
         )
     )
+    parser = UpdateManager.add_argparse_arguments(parser)
     parser = FlightController.add_argparse_arguments(parser)
     parser = LocalFilesystem.add_argparse_arguments(parser)
     parser = ComponentEditorWindow.add_argparse_arguments(parser)
     parser = ParameterEditorWindow.add_argparse_arguments(parser)
-    parser = UpdateManager.add_argparse_arguments(parser)
     parser = add_common_arguments(parser)
 
     argcomplete.autocomplete(parser)
@@ -128,14 +135,27 @@ def component_editor(
         webbrowser_open(url=url, new=0, autoraise=True)
     component_editor_window.root.mainloop()
 
-    if vehicle_dir_window and vehicle_dir_window.configuration_template and vehicle_dir_window.use_fc_params.get():
-        error_message = local_filesystem.copy_fc_params_values_to_template_created_vehicle_files(
-            flight_controller.fc_parameters
-        )
-        if error_message:
-            logging_error(error_message)
-            show_error_message(_("Error in derived parameters"), error_message)
-            sys_exit(1)
+    source_param_values: Union[dict[str, float], None] = (
+        flight_controller.fc_parameters
+        if vehicle_dir_window and vehicle_dir_window.configuration_template and vehicle_dir_window.use_fc_params.get()
+        else None
+    )
+    existing_fc_params: list[str] = (
+        list(flight_controller.fc_parameters.keys())
+        if flight_controller.fc_parameters
+        else list(local_filesystem.param_default_dict.keys())
+        if local_filesystem.param_default_dict
+        else []
+    )
+    # if source_param_values is None, the template parameter values are used
+    # if source_param_values contains the connected FC parameters, then they are used
+    error_message = local_filesystem.update_and_export_vehicle_params_from_fc(
+        source_param_values=source_param_values, existing_fc_params=existing_fc_params
+    )
+    if error_message:
+        logging_error(error_message)
+        show_error_message(_("Error in derived parameters"), error_message)
+        sys_exit(1)
 
 
 def main() -> None:

ardupilot_methodic_configurator/backend_filesystem.py

@@ -23,7 +23,7 @@ from re import compile as re_compile
 from shutil import copy2 as shutil_copy2
 from shutil import copytree as shutil_copytree
 from subprocess import SubprocessError, run
-from typing import Any, Optional
+from typing import Any, Optional, Union
 from zipfile import ZipFile
 
 from argcomplete.completers import DirectoriesCompleter
@@ -612,23 +612,76 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
             variables["doc_dict"] = self.doc_dict
         return variables
 
-    def copy_fc_params_values_to_template_created_vehicle_files(self, fc_parameters: dict[str, float]) -> str:
+    def update_and_export_vehicle_params_from_fc(
+        self, source_param_values: Union[dict[str, float], None], existing_fc_params: list[str]
+    ) -> str:
+        """
+        Update parameter values from flight controller data and export to vehicle files.
+
+        This function performs several operations in sequence:
+        1. Updates parameter values using the provided source values
+        2. Computes forced parameters based on configuration steps
+        3. Computes derived parameters that depend on other parameters
+        4. Exports the updated parameters to files in the vehicle directory
+
+        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+
+                                assumed to exist
+
+        Returns:
+            str: Empty string if successful, error message otherwise.
+
+        """
         eval_variables = self.get_eval_variables()
+        # the eval variables do not contain fc_parameter values
+        # and that is intentional, the fc_parameters are not to be used in here
         for param_filename, param_dict in self.file_parameters.items():
             for param_name, param in param_dict.items():
-                if param_name in fc_parameters:
-                    param.value = fc_parameters[param_name]
+                if source_param_values and param_name in source_param_values:
+                    param.value = source_param_values[param_name]
             if self.configuration_steps and param_filename in self.configuration_steps:
                 step_dict = self.configuration_steps[param_filename]
                 error_msg = self.compute_parameters(param_filename, step_dict, "forced", eval_variables)
                 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)
                 if error_msg:
                     return error_msg
+                self.merge_forced_or_derived_parameters(param_filename, self.derived_parameters, existing_fc_params)
             Par.export_to_param(Par.format_params(param_dict), os_path.join(self.vehicle_dir, param_filename))
         return ""
 
+    def merge_forced_or_derived_parameters(
+        self, filename: str, new_parameters: dict[str, dict[str, Par]], existing_fc_params: Optional[list[str]]
+    ) -> bool:
+        """
+        Merge forced or derived parameter values in the self.file_parameter list.
+
+        Args:
+            filename: The name of the parameter file
+            new_parameters: Dictionary of new parameters to potentially add
+            existing_fc_params: Optional list of flight controller parameters names
+
+        """
+        if new_parameters is None or filename not in new_parameters:
+            return False
+
+        at_least_one_param_changed = False
+        for param_name, param in new_parameters[filename].items():
+            if filename not in self.file_parameters:
+                continue
+            if existing_fc_params is None or not existing_fc_params or param_name in existing_fc_params:
+                if param_name in self.file_parameters[filename]:
+                    if not is_within_tolerance(self.file_parameters[filename][param_name].value, param.value):
+                        at_least_one_param_changed = True
+                else:
+                    at_least_one_param_changed = True
+                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()))
         if self.param_default_dict != param_default_values:

ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -12,17 +12,17 @@ from json import JSONDecodeError
 from json import dump as json_dump
 from json import load as json_load
 
-# from logging import info as logging_info
 # from logging import warning as logging_warning
 # from sys import exit as sys_exit
 from logging import debug as logging_debug
 from logging import error as logging_error
+from logging import info as logging_info
 from os import path as os_path
 from os import walk as os_walk
 from re import match as re_match
 from typing import Any, Union
 
-from jsonschema import ValidationError, validate
+from jsonschema import ValidationError, validate, validators
 
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
@@ -55,7 +55,21 @@ class VehicleComponents:
 
         try:
             with open(schema_path, encoding="utf-8") as file:
-                self.schema = json_load(file)
+                loaded_schema: dict[Any, Any] = json_load(file)
+
+                # Validate the schema itself against the JSON Schema meta-schema
+                try:
+                    # Get the Draft7Validator class which has the META_SCHEMA property
+                    validator_class = validators.Draft7Validator
+                    meta_schema = validator_class.META_SCHEMA
+
+                    # Validate the loaded schema against the meta-schema
+                    validate(instance=loaded_schema, schema=meta_schema)
+                    logging_debug(_("Schema file '%s' is valid."), schema_path)
+                except Exception as e:  # pylint: disable=broad-exception-caught
+                    logging_error(_("Schema file '%s' is not a valid JSON Schema: %s"), schema_path, str(e))
+
+                self.schema = loaded_schema
             return self.schema
         except FileNotFoundError:
             logging_error(_("Schema file '%s' not found."), schema_path)
@@ -118,7 +132,7 @@ class VehicleComponents:
 
         filepath = os_path.join(vehicle_dir, self.vehicle_components_json_filename)
         try:
-            with open(filepath, "w", encoding="utf-8") as file:
+            with open(filepath, "w", encoding="utf-8", newline="\n") as file:
                 json_dump(data, file, indent=4)
         except FileNotFoundError:
             msg = _("Directory '{}' not found").format(vehicle_dir)
@@ -249,3 +263,218 @@ class VehicleComponents:
             else:
                 # For strings and other types, set to empty string or None
                 data[key] = "" if isinstance(value, str) else None
+
+    def get_component_property_description(self, path: tuple[str, ...]) -> tuple[str, bool]:
+        """
+        Get description and optional status from schema using a component path.
+
+        Args:
+            path (tuple): The path to the component in the JSON data.
+
+        Returns:
+            tuple[str, bool]: A tuple containing (description, is_optional),
+                            where is_optional defaults to False if not specified.
+
+        """
+        if not path or len(path) == 0:
+            return ("", False)
+
+        try:
+            # Start with the Components node since all our editable items are under it
+            current = self.schema.get("properties", {}).get("Components", {})  # type: ignore[union-attr]
+
+            # Handle different path scenarios
+            if len(path) == 1:
+                return self._get_top_level_component_description(current, path[0])
+            if len(path) == 3 and path[1] == "Product":
+                return self._get_product_field_description(path[2])
+            return self._get_nested_property_description(current, path)
+        except Exception as _e:  # pylint: disable=broad-exception-caught
+            msg = _("Exception occurred in get_component_property_description: {}").format(str(_e))
+            logging_error(msg)
+            return ("", False)
+
+    def _get_top_level_component_description(self, current_schema: dict[str, Any], component_type: str) -> tuple[str, bool]:
+        """Get description for top-level components like 'Flight Controller'."""
+        if component_type in current_schema.get("properties", {}):
+            description = current_schema["properties"][component_type].get("description", "")
+            is_optional = current_schema["properties"][component_type].get("x-is-optional", False)
+            return (description, is_optional)
+        return ("", False)
+
+    def _get_product_field_description(self, field_name: str) -> tuple[str, bool]:
+        """Get description for product fields (Manufacturer, Model, etc.)."""
+        product_def = self.schema.get("definitions", {}).get("product", {})  # type: ignore[union-attr]
+        if "properties" in product_def and field_name in product_def["properties"]:
+            description = product_def["properties"][field_name].get("description", "")
+            is_optional = product_def["properties"][field_name].get("x-is-optional", False)
+            return (description, is_optional)
+        return ("", False)
+
+    def _get_nested_property_description(self, current_schema: dict[str, Any], path: tuple[str, ...]) -> tuple[str, bool]:
+        """Get description for nested properties in the component structure."""
+        # Get the component type (e.g., "Flight Controller")
+        component_type = path[0]
+
+        # Navigate to the specific component type
+        if component_type in current_schema.get("properties", {}):
+            current = current_schema["properties"][component_type]
+        else:
+            return ("", False)
+
+        # Resolve reference if present
+        current = self._resolve_schema_reference(current)
+
+        # Handle requests for section fields (Product, Firmware, Specifications, etc.)
+        if len(path) == 2:
+            return self._get_section_field_description(current, path[1])
+
+        # For deeper nested fields, navigate through the path
+        return self._traverse_nested_path(current, path[1:])
+
+    def _resolve_schema_reference(self, schema_obj: dict[str, Any]) -> dict[str, Any]:
+        """Resolve a schema reference in the form of {"$ref": "#/path/to/definition"}."""
+        if "$ref" in schema_obj:
+            ref_path = schema_obj["$ref"].replace("#/", "").split("/")
+            ref_obj = self.schema
+            for ref_part in ref_path:
+                ref_obj = ref_obj.get(ref_part, {})  # type: ignore[union-attr]
+            return ref_obj  # type: ignore[return-value]
+        return schema_obj
+
+    def _get_section_field_description(self, current: dict[str, Any], section: str) -> tuple[str, bool]:
+        """Get description for section fields like Product, Firmware, etc."""
+        # First check in direct properties
+        if "properties" in current and section in current["properties"]:
+            description = current["properties"][section].get("description", "")
+            is_optional = current["properties"][section].get("x-is-optional", False)
+            return (description, is_optional)
+
+        # Then check in allOf constructs
+        if "allOf" in current:
+            for allof_item in current["allOf"]:
+                # Handle reference in allOf item
+                if "$ref" in allof_item:
+                    ref_obj = self._resolve_schema_reference(allof_item)
+
+                    if "properties" in ref_obj and section in ref_obj["properties"]:
+                        description = ref_obj["properties"][section].get("description", "")
+                        is_optional = ref_obj["properties"][section].get("x-is-optional", False)
+                        return (description, is_optional)
+
+                # Direct properties check in this allOf item
+                elif "properties" in allof_item and section in allof_item["properties"]:
+                    description = allof_item["properties"][section].get("description", "")
+                    is_optional = allof_item["properties"][section].get("x-is-optional", False)
+                    return (description, is_optional)
+
+        # If not found, return empty with default optional status
+        return ("", False)
+
+    def _traverse_nested_path(self, current: dict[str, Any], path_parts: tuple[str, ...]) -> tuple[str, bool]:
+        """Traverse a nested path in the schema to find a property description."""
+        for part in path_parts:
+            found = False
+
+            # Check strategies in order: direct properties, allOf, and references
+            found, current = self._check_direct_properties(current, part)
+            if not found:
+                found, current = self._check_allof_constructs(current, part)
+            if not found:
+                found, current = self._check_references(current, part)
+
+            # If not found after all checks, return empty
+            if not found:
+                return ("", False)
+
+            # If we found a $ref in the current object, resolve it
+            current = self._resolve_schema_reference(current)
+
+        # Return the description and optional status of the final object
+        description = current.get("description", "")
+        is_optional = current.get("x-is-optional", False)
+        return (description, is_optional)
+
+    def _check_direct_properties(self, schema_obj: dict[str, Any], property_name: str) -> tuple[bool, dict]:
+        """Check if property exists directly in schema's properties."""
+        if "properties" in schema_obj and property_name in schema_obj["properties"]:
+            return True, schema_obj["properties"][property_name]
+        return False, schema_obj
+
+    def _check_allof_constructs(self, schema_obj: dict[str, Any], property_name: str) -> tuple[bool, dict]:
+        """Check if property exists in any allOf constructs."""
+        if "allOf" in schema_obj:
+            for allof_item in schema_obj["allOf"]:
+                # Handle reference in allOf item
+                if "$ref" in allof_item:
+                    ref_obj = self._resolve_schema_reference(allof_item)
+
+                    if "properties" in ref_obj and property_name in ref_obj["properties"]:
+                        return True, ref_obj["properties"][property_name]
+
+                # Direct check in this allOf item
+                elif "properties" in allof_item and property_name in allof_item["properties"]:
+                    return True, allof_item["properties"][property_name]
+
+        return False, schema_obj
+
+    def _check_references(self, schema_obj: dict[str, Any], property_name: str) -> tuple[bool, dict]:
+        """Check if property exists in referenced schema object."""
+        if "$ref" in schema_obj:
+            ref_obj = self._resolve_schema_reference(schema_obj)
+
+            # Look in the resolved reference direct properties
+            if "properties" in ref_obj and property_name in ref_obj["properties"]:
+                return True, ref_obj["properties"][property_name]
+
+            # Look in allOf constructs in the reference
+            if "allOf" in ref_obj:
+                for allof_item in ref_obj["allOf"]:
+                    if "properties" in allof_item and property_name in allof_item["properties"]:
+                        return True, allof_item["properties"][property_name]
+
+        return False, schema_obj
+
+
+def main() -> None:
+    """Main function for standalone execution."""
+    vehicle_components = VehicleComponents()
+    vehicle_components.load_schema()
+
+    component_property_paths = [
+        ("Flight Controller", "Product", "Manufacturer"),
+        ("Flight Controller", "Product", "Model"),
+        ("Flight Controller", "Product", "URL"),
+        ("Flight Controller", "Product", "Version"),
+        ("Flight Controller", "Firmware", "Type"),
+        ("Flight Controller", "Firmware", "Version"),
+        ("Flight Controller", "Specifications", "MCU Series"),
+        ("Flight Controller", "Notes"),
+        ("Flight Controller",),
+        ("Flight Controller", "Product"),
+        ("Flight Controller", "Firmware"),
+        ("Flight Controller", "Specifications"),
+        ("Frame",),
+        ("Frame", "Product"),
+        ("Frame", "Specifications"),
+        ("Frame", "Product", "Manufacturer"),
+        ("Frame", "Product", "Model"),
+        ("Frame", "Product", "URL"),
+        ("Frame", "Product", "Version"),
+        ("Frame", "Specifications", "TOW min Kg"),
+        ("Frame", "Specifications", "TOW max Kg"),
+        ("Frame", "Notes"),
+    ]
+
+    logging_info("\nTesting description lookup for sample paths:")
+    logging_info("=============================================")
+
+    for path in component_property_paths:
+        desc, is_optional = vehicle_components.get_component_property_description(path)
+        msg = f"Path: {path}\nDescription: {desc}, Optional: {is_optional}"
+        logging_info(msg)
+        logging_info("-" * 50)
+
+
+if __name__ == "__main__":
+    main()

ardupilot_methodic_configurator/frontend_tkinter_autoresize_combobox.py

@@ -0,0 +1,66 @@
+"""
+TKinter base classes reused in multiple parts of the code.
+
+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
+"""
+
+# https://wiki.tcl-lang.org/page/Changing+Widget+Colors
+
+from logging import error as logging_error
+from logging import warning as logging_warning
+from tkinter import ttk
+from typing import Union
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
+
+
+def update_combobox_width(combobox: ttk.Combobox) -> None:
+    # Calculate the maximum width needed for the content
+    values = combobox["values"]
+    max_width = max(len(value) for value in values) if values else 0
+    # Set a minimum width for the combobox
+    min_width = 4  # Adjust this value as needed
+    # Set the width of the combobox to the maximum width, but not less than the minimum width
+    combobox.config(width=max(min_width, max_width))
+
+
+class AutoResizeCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
+    """
+    A custom Combobox widget that automatically resizes based on its content.
+
+    This class extends the ttk.Combobox widget to include functionality for
+    automatically adjusting its width based on the longest entry in its list of
+    values. It also supports displaying a tooltip when hovering over the widget.
+
+    Attributes:
+        master: The parent container in which the Combobox is placed.
+        values: A tuple of strings representing the entries in the Combobox.
+        selected_element: The initially selected element in the Combobox.
+        tooltip: A string representing the tooltip text to display when hovering over the widget.
+
+    """
+
+    def __init__(
+        self, master: ttk.Frame, values: list[str], selected_element: str, tooltip: Union[None, str], *args, **kwargs
+    ) -> None:
+        super().__init__(master, *args, **kwargs)
+        self.set_entries_tuple(values, selected_element, tooltip)
+
+    def set_entries_tuple(self, values: list[str], selected_element: str, tooltip: Union[None, str] = None) -> None:
+        self["values"] = tuple(values)
+        if selected_element:
+            if selected_element in values:
+                self.set(selected_element)
+            else:
+                logging_error(_("param_file combobox selected string '%s' not in list %s"), selected_element, values)
+        elif values:
+            logging_warning(_("No param_file combobox element selected"))
+        if values:
+            update_combobox_width(self)
+        if tooltip:
+            show_tooltip(self, tooltip)