ardupilot-methodic-configurator 1.2.3__py3-none-any.whl → 1.4.0__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.3"
+__version__ = "1.4.0"

ardupilot_methodic_configurator/__main__.py

@@ -34,6 +34,7 @@ from ardupilot_methodic_configurator import _, __version__
 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.backend_internet import verify_and_open_url
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
 from ardupilot_methodic_configurator.frontend_tkinter_component_editor import ComponentEditorWindow
 from ardupilot_methodic_configurator.frontend_tkinter_connection_selection import ConnectionSelectionWindow
@@ -46,7 +47,7 @@ from ardupilot_methodic_configurator.middleware_software_updates import UpdateMa
 
 def create_argument_parser() -> argparse.ArgumentParser:
     """
-    This function sets up an argument parser to handle the command-line arguments for the script.
+    Argument parser to handle the command-line arguments for the script.
 
     Returns:
         argparse.ArgumentParser: The argument parser object.
@@ -128,11 +129,16 @@ def component_editor(
         and flight_controller.info.firmware_type != _("Unknown")
         and flight_controller.info.firmware_type != ""
     ):
-        url = (
-            "https://github.com/ArduPilot/ardupilot/blob/master/libraries/AP_HAL_ChibiOS/hwdef/"
-            f"{flight_controller.info.firmware_type}/README.md"
-        )
-        webbrowser_open(url=url, new=0, autoraise=True)
+        firmware_type = flight_controller.info.firmware_type
+        url = f"https://github.com/ArduPilot/ardupilot/blob/master/libraries/AP_HAL_ChibiOS/hwdef/{firmware_type}/README.md"
+        url_found = verify_and_open_url(url)
+        if not url_found and firmware_type.endswith("-bdshot"):
+            firmware_type = firmware_type[:-7]
+            url = (
+                f"https://github.com/ArduPilot/ardupilot/blob/master/libraries/AP_HAL_ChibiOS/hwdef/{firmware_type}/README.md"
+            )
+            url_found = verify_and_open_url(url)
+
     component_editor_window.root.mainloop()
 
     source_param_values: Union[dict[str, float], None] = (
@@ -184,7 +190,11 @@ def main() -> None:
 
     try:
         local_filesystem = LocalFilesystem(
-            args.vehicle_dir, vehicle_type, flight_controller.info.flight_sw_version, args.allow_editing_template_files
+            args.vehicle_dir,
+            vehicle_type,
+            flight_controller.info.flight_sw_version,
+            args.allow_editing_template_files,
+            args.save_component_to_system_templates,
         )
     except SystemExit as exp:
         show_error_message(_("Fatal error reading parameter files"), f"{exp}")

ardupilot_methodic_configurator/annotate_params.py

@@ -329,6 +329,7 @@ class Par:
     def print_out(formatted_params: list[str], name: str) -> None:
         """
         Print out the contents of the provided list.
+
         If the list is too large, print only the ones that fit on the screen and
         wait for user input to continue.
 
@@ -564,6 +565,7 @@ def create_doc_dict(root: ET.Element, vehicle_type: str, max_line_length: int =
 def format_columns(values: dict[str, Any], max_width: int = 105, max_columns: int = 4) -> list[str]:
     """
     Formats a dictionary of values into column-major horizontally aligned columns.
+
     It uses at most max_columns columns.
 
     Args:
@@ -727,8 +729,6 @@ def update_parameter_documentation_file(  # pylint: disable=too-many-locals, too
     delete_documentation_annotations: bool,
 ) -> None:
     new_lines = []
-    if os_path.basename(param_file).endswith("16_pid_adjustment.param"):
-        new_lines.extend(lines[0:5])  # copy the first 6 lines verbatim
 
     total_params = 0
     documented_params = 0

ardupilot_methodic_configurator/backend_filesystem.py

@@ -85,9 +85,16 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
 
     """
 
-    def __init__(self, vehicle_dir: str, vehicle_type: str, fw_version: str, allow_editing_template_files: bool) -> None:
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        vehicle_dir: str,
+        vehicle_type: str,
+        fw_version: str,
+        allow_editing_template_files: bool,
+        save_component_to_system_templates: bool,
+    ) -> None:
         self.file_parameters: dict[str, dict[str, Par]] = {}
-        VehicleComponents.__init__(self)
+        VehicleComponents.__init__(self, save_component_to_system_templates)
         ConfigurationSteps.__init__(self, vehicle_dir, vehicle_type)
         ProgramSettings.__init__(self)
         self.vehicle_type = vehicle_type
@@ -208,7 +215,15 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 try:
                     param_info["Values"] = {int(k): v for k, v in param_info["values"].items()}
                 except ValueError:
-                    param_info["Values"] = {float(k): v for k, v in param_info["values"].items()}
+                    try:
+                        param_info["Values"] = {float(k): v for k, v in param_info["values"].items()}
+                    except ValueError:
+                        logging_warning(_("Could not convert values to int or float for %s"), param_name)
+                        logging_warning(
+                            _("Parameter %s has invalid metadata. Please file a bug at %s"),
+                            param_name,
+                            "https://github.com/ArduPilot/ardupilot/issues",
+                        )
                 # print(param_info['Values'])
 
             prefix_parts = [
@@ -424,7 +439,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         with ZipFile(zip_file_path, "w") as zipf:
             # Add all intermediate parameter files
             for file_name in self.file_parameters:
-                zipf.write(os_path.join(self.vehicle_dir, file_name), arcname=file_name)
+                self.add_configuration_file_to_zip(zipf, file_name)
                 # Add step-specific documentation metadata files
                 pdef_xml_file = file_name.replace(".param", ".pdef.xml")
                 self.add_configuration_file_to_zip(zipf, pdef_xml_file)
@@ -651,7 +666,9 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 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))
+            self.export_to_param(
+                param_dict, param_filename, annotate_doc=bool(ProgramSettings.get_setting("annotate_docs_into_param_files"))
+            )
         return ""
 
     def merge_forced_or_derived_parameters(
@@ -781,4 +798,13 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 "Default is %(default)s"
             ),
         )
+        parser.add_argument(
+            "--save-component-to-system-templates",
+            action="store_true",
+            help=_(
+                "Save the vehicle component to the system templates. "
+                "Only for software developers that know what they are doing. "
+                "Default is %(default)s"
+            ),
+        )
         return parser

ardupilot_methodic_configurator/backend_filesystem_configuration_steps.py

@@ -189,7 +189,8 @@ class ConfigurationSteps:
 
                 if filename not in destination:
                     destination[filename] = {}
-                destination[filename][parameter] = Par(float(result), parameter_info["Change Reason"])
+                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:
                 error_msg = _(
                     "In file '{self.configuration_steps_filename}': '{filename}' {parameter_type} "

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -72,8 +72,7 @@ class ProgramSettings:
     @staticmethod
     def valid_directory_name(dir_name: str) -> bool:
         """
-        Check if a given directory name contains only alphanumeric characters, underscores, hyphens,
-        and the OS directory separator.
+        Check if a name contains only alphanumeric characters, underscores, hyphens and the OS directory separator.
 
         This function is designed to ensure that the directory name does not contain characters that are
         invalid for directory names in many operating systems. It does not guarantee that the name

ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -17,6 +17,7 @@ from json import load as json_load
 from logging import debug as logging_debug
 from logging import error as logging_error
 from logging import info as logging_info
+from os import makedirs as os_makedirs
 from os import path as os_path
 from os import walk as os_walk
 from re import match as re_match
@@ -30,16 +31,14 @@ from ardupilot_methodic_configurator.middleware_template_overview import Templat
 
 
 class VehicleComponents:
-    """
-    This class provides methods to load and save
-    vehicle components configurations from a JSON file.
-    """
+    """Load and save vehicle components configurations from a JSON file."""
 
-    def __init__(self) -> None:
+    def __init__(self, save_component_to_system_templates: bool = False) -> None:
         self.vehicle_components_json_filename = "vehicle_components.json"
         self.vehicle_components_schema_filename = "vehicle_components_schema.json"
         self.vehicle_components: Union[None, dict[Any, Any]] = None
         self.schema: Union[None, dict[Any, Any]] = None
+        self.save_component_to_system_templates = save_component_to_system_templates
 
     def load_schema(self) -> dict:
         """
@@ -77,6 +76,207 @@ class VehicleComponents:
             logging_error(_("Error decoding JSON schema from file '%s'."), schema_path)
         return {}
 
+    def load_component_templates(self) -> dict[str, list[dict]]:
+        """
+        Load component templates from both system and user templates directories.
+
+        User templates take precedence over system templates.
+
+        :return: The merged templates as a dictionary
+        """
+        # Load system templates (read-only, comes with software)
+        system_templates = self._load_system_templates()
+
+        # Load user templates (user-editable)
+        user_templates = self._load_user_templates()
+
+        # Merge templates, with user templates taking precedence
+        merged_templates = system_templates.copy()
+        for component_name, templates in user_templates.items():
+            if component_name not in merged_templates:
+                merged_templates[component_name] = []
+
+            # Add each user template, replacing system templates with the same name
+            for user_template in templates:
+                template_name = user_template.get("name")
+                if template_name:
+                    # Add a flag to mark this as a user template
+                    user_template["is_user_modified"] = True
+
+                    # Find index of system template with same name, if any
+                    replaced = False
+                    for i, template in enumerate(merged_templates.get(component_name, [])):
+                        if template.get("name") == template_name:
+                            merged_templates[component_name][i] = user_template
+                            replaced = True
+                            break
+
+                    if not replaced:
+                        merged_templates.setdefault(component_name, []).append(user_template)
+
+        return merged_templates
+
+    def _load_system_templates(self) -> dict[str, list[dict]]:
+        """
+        Load system component templates.
+
+        :return: The system component templates as a dictionary
+        """
+        templates_filename = "system_vehicle_components_template.json"
+        templates_dir = ProgramSettings.get_templates_base_dir()
+        filepath = os_path.join(templates_dir, templates_filename)
+
+        templates = {}
+        try:
+            with open(filepath, encoding="utf-8") as file:
+                templates = json_load(file)
+        except FileNotFoundError:
+            logging_debug(_("System component templates file '%s' not found."), filepath)
+        except JSONDecodeError:
+            logging_error(_("Error decoding JSON system component templates from file '%s'."), filepath)
+        return templates
+
+    def _load_user_templates(self) -> dict[str, list[dict]]:
+        """
+        Load user component templates.
+
+        :return: The user component templates as a dictionary
+        """
+        templates_filename = "user_vehicle_components_template.json"
+        templates_dir = ProgramSettings.get_templates_base_dir()
+        filepath = os_path.join(templates_dir, templates_filename)
+
+        templates = {}
+        try:
+            with open(filepath, encoding="utf-8") as file:
+                templates = json_load(file)
+        except FileNotFoundError:
+            logging_debug(_("User component templates file '%s' not found."), filepath)
+        except JSONDecodeError:
+            logging_error(_("Error decoding JSON user component templates from file '%s'."), filepath)
+        return templates
+
+    def save_component_templates(self, templates: dict) -> tuple[bool, str]:  # pylint: disable=too-many-branches
+        """
+        Save component templates.
+
+        For user templates: Only save templates that are user-modified or not present in system templates.
+        For system templates: Merge with existing system templates, adding new ones.
+
+        :param templates: The templates to save
+        :return: A tuple of (error_occurred, error_message)
+        """
+        # Load system templates to compare against
+        system_templates = self._load_system_templates()
+
+        # Determine which templates need to be saved to user file
+        templates_to_save: dict[str, list[dict[str, Any]]] = {}
+
+        if self.save_component_to_system_templates:
+            # For system templates, start with existing system templates
+            templates_to_save = system_templates.copy()
+
+            # Then add new templates that don't exist yet
+            for component_name, component_templates in templates.items():
+                if component_name not in templates_to_save:
+                    templates_to_save[component_name] = []
+
+                # Create a mapping of existing template names for this component
+                existing_template_names = {t.get("name"): True for t in templates_to_save[component_name]}
+
+                for template in component_templates:
+                    template_name = template.get("name")
+                    if not template_name:
+                        continue
+
+                    # Only add if it doesn't exist in system templates yet
+                    if template_name not in existing_template_names:
+                        template_copy = template.copy()
+                        if "is_user_modified" in template_copy:
+                            del template_copy["is_user_modified"]
+                        templates_to_save[component_name].append(template_copy)
+                        existing_template_names[template_name] = True
+        else:
+            for component_name, component_templates in templates.items():
+                templates_to_save[component_name] = []
+
+                # Create a mapping of system template names for this component
+                if component_name in system_templates:
+                    system_template_names = {t.get("name"): t for t in system_templates.get(component_name, [])}
+                else:
+                    system_template_names = {}
+
+                for template in component_templates:
+                    template_name = template.get("name")
+                    if not template_name:
+                        continue
+
+                    # If the template is marked as user-modified, save it
+                    if template.get("is_user_modified", False):
+                        # Remove the flag before saving
+                        template_copy = template.copy()
+                        if "is_user_modified" in template_copy:
+                            del template_copy["is_user_modified"]
+                        templates_to_save[component_name].append(template_copy)
+                        continue
+
+                    # If the template exists in system templates, check if it's different
+                    if template_name in system_template_names:
+                        system_template = system_template_names[template_name]
+
+                        # Deep comparison of data section
+                        if template.get("data") != system_template.get("data"):
+                            # Template is modified from system version
+                            template_copy = template.copy()
+                            templates_to_save[component_name].append(template_copy)
+                    else:
+                        # Template doesn't exist in system templates, so it's user-added
+                        templates_to_save[component_name].append(template.copy())
+
+                # Remove empty component entries
+                if not templates_to_save[component_name]:
+                    del templates_to_save[component_name]
+
+        return self.save_component_templates_to_file(templates_to_save)
+
+    def save_component_templates_to_file(self, templates_to_save: dict[str, list[dict[str, Any]]]) -> tuple[bool, str]:
+        if self.save_component_to_system_templates:
+            # Save to system templates file
+            templates_filename = "system_vehicle_components_template.json"
+        else:
+            # Save to user templates file
+            templates_filename = "user_vehicle_components_template.json"
+        templates_dir = ProgramSettings.get_templates_base_dir()
+
+        # Create the directory if it doesn't exist
+        try:
+            os_makedirs(templates_dir, exist_ok=True)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            msg = _("Failed to create templates directory '{}': {}").format(templates_dir, str(e))
+            logging_error(msg)
+            return True, msg
+
+        # Now create the file path and write to it
+        filepath = os_path.join(templates_dir, templates_filename)
+
+        try:
+            with open(filepath, "w", encoding="utf-8") as file:
+                json_dump(templates_to_save, file, indent=4)
+            return False, ""  # Success
+        except FileNotFoundError:
+            msg = _("File not found when writing to '{}': {}").format(filepath, _("Path not found"))
+            logging_error(msg)
+        except PermissionError:
+            msg = _("Permission denied when writing to file '{}'").format(filepath)
+            logging_error(msg)
+        except OSError as e:
+            msg = _("OS error when writing to file '{}': {}").format(filepath, str(e))
+            logging_error(msg)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            msg = _("Unexpected error saving templates to file '{}': {}").format(filepath, str(e))
+            logging_error(msg)
+        return True, msg
+
     def validate_vehicle_components(self, data: dict) -> tuple[bool, str]:
         """
         Validate vehicle components data against the schema.
@@ -200,8 +400,9 @@ class VehicleComponents:
     @staticmethod
     def get_vehicle_components_overviews() -> dict[str, TemplateOverview]:
         """
-        Finds all subdirectories of the templates base directory containing a
-        "vehicle_components.json" file, creates a dictionary where the keys are
+        Finds all subdirectories of the templates base directory containing a "vehicle_components.json" file.
+
+        Creates a dictionary where the keys are
         the subdirectory names (relative to templates base directory) and the
         values are instances of TemplateOverview.
 
@@ -294,21 +495,23 @@ class VehicleComponents:
             logging_error(msg)
             return ("", False)
 
+    def _get_component_schema_property_description(self, component_info: dict[str, Any]) -> tuple[str, bool]:
+        """Get description and optional status from a component schema property."""
+        description = component_info.get("description", "")
+        is_optional = component_info.get("x-is-optional", False)
+        return (description, is_optional)
+
     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 self._get_component_schema_property_description(current_schema["properties"][component_type])
         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 self._get_component_schema_property_description(product_def["properties"][field_name])
         return ("", False)
 
     def _get_nested_property_description(self, current_schema: dict[str, Any], path: tuple[str, ...]) -> tuple[str, bool]:
@@ -346,9 +549,7 @@ class VehicleComponents:
         """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)
+            return self._get_component_schema_property_description(current["properties"][section])
 
         # Then check in allOf constructs
         if "allOf" in current:
@@ -358,15 +559,11 @@ class VehicleComponents:
                     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)
+                        return self._get_component_schema_property_description(ref_obj["properties"][section])
 
                 # 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)
+                    return self._get_component_schema_property_description(allof_item["properties"][section])
 
         # If not found, return empty with default optional status
         return ("", False)
@@ -391,9 +588,7 @@ class VehicleComponents:
             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)
+        return self._get_component_schema_property_description(current)
 
     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."""

ardupilot_methodic_configurator/backend_flightcontroller_info.py

@@ -126,7 +126,8 @@ class BackendFlightcontrollerInfo:  # pylint: disable=too-many-instance-attribut
     @staticmethod
     def __decode_flight_sw_version(flight_sw_version: int) -> tuple[int, int, int, str]:
         """
-        Decode 32 bit flight_sw_version mavlink parameter
+        Decode 32 bit flight_sw_version mavlink parameter.
+
         corresponds to ArduPilot encoding in  GCS_MAVLINK::send_autopilot_version.
         """
         fw_type_id = (flight_sw_version >> 0) % 256  # E221, E222
@@ -151,6 +152,7 @@ class BackendFlightcontrollerInfo:  # pylint: disable=too-many-instance-attribut
     def __decode_flight_capabilities(capabilities: int) -> dict[str, str]:
         """
         Decode 32 bit flight controller capabilities bitmask mavlink parameter.
+
         Returns a dict of concise English descriptions of each active capability.
         """
         capabilities_dict: dict[str, str] = {}

ardupilot_methodic_configurator/backend_internet.py

@@ -12,10 +12,12 @@ import os
 import subprocess
 import tempfile
 from datetime import datetime, timezone
+from logging import debug as logging_debug
 from logging import error as logging_error
 from logging import info as logging_info
 from typing import Any, Callable, Optional
 from urllib.parse import urljoin
+from webbrowser import open as webbrowser_open
 
 from requests import HTTPError as requests_HTTPError
 from requests import RequestException as requests_RequestException
@@ -195,3 +197,49 @@ def download_and_install_pip_release(progress_callback: Optional[Callable[[float
         progress_callback(100.0, _("Download complete"))
 
     return ret
+
+
+def verify_and_open_url(url: str) -> bool:
+    """
+    Verify if a URL is accessible and open it in the default web browser if successful.
+
+    Args:
+        url: The URL to verify and open
+
+    Returns:
+        bool: True if the URL was found and opened, False otherwise
+
+    """
+    if not url:
+        logging_error(_("URL not provided."))
+        return False
+
+    logging_debug(_("Verifying URL: %s"), url)
+    url_found: bool = False
+
+    try:
+        # Get proxy settings from environment variables
+        proxies_dict = {
+            "http": os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy"),
+            "https": os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy"),
+            "no_proxy": os.environ.get("NO_PROXY") or os.environ.get("no_proxy"),
+        }
+        # Remove None values
+        proxies = {k: v for k, v in proxies_dict.items() if v is not None}
+
+        # Use requests.get with allow_redirects to handle HTTP redirects properly
+        response = requests_get(url, timeout=5, stream=True, allow_redirects=True, proxies=proxies, verify=True)
+        url_found = response.status_code == 200
+    except (requests_RequestException, requests_Timeout) as e:
+        logging_error(_("Failed to access URL: %s. Error: %s"), url, str(e))
+        url_found = False
+
+    if url_found:
+        try:
+            logging_info(_("Opening URL in browser: %s"), url)
+            webbrowser_open(url=url, new=0, autoraise=True)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging_error(_("Failed to open URL in browser: %s"), str(e))
+            url_found = False
+
+    return url_found

ardupilot_methodic_configurator/battery_cell_voltages.py

@@ -59,7 +59,7 @@ battery_cell_voltages = {
 
 class BatteryCell:
     """
-    This class provides methods to work with battery cell voltages for different chemistries.
+    Battery cell voltages for different chemistries.
 
     It includes methods to get the tuple of chemistries, limit voltages based on chemistry type,
     and get recommended voltages for a given chemistry.