ardupilot-methodic-configurator 2.6.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

ardupilot_methodic_configurator/__init__.py

@@ -1,7 +1,7 @@
 """
 Python package initialization file. Loads translations and declares version information.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -12,4 +12,4 @@ from ardupilot_methodic_configurator.internationalization import load_translatio
 
 _ = load_translation()
 
-__version__ = "2.6.0"
+__version__ = "2.7.0"

ardupilot_methodic_configurator/__main__.py

@@ -11,7 +11,7 @@ Calls five sub-applications in sequence:
   4. Component and connection editor
   5. Parameter editor and uploader
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -19,6 +19,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 """
 
 import argparse
+import os
 from logging import basicConfig as logging_basicConfig
 from logging import debug as logging_debug
 from logging import error as logging_error
@@ -497,6 +498,9 @@ def main() -> None:
     """
     args = create_argument_parser().parse_args()
 
+    # Create desktop icon if needed (only on first run in venv)
+    ProgramSettings.create_desktop_icon_if_needed()
+
     state = ApplicationState(args)
 
     setup_logging(state)
@@ -517,6 +521,26 @@ def main() -> None:
     if not files:
         vehicle_directory_selection(state)
 
+    if (
+        state.flight_controller.fc_parameters
+        and state.flight_controller.info.flight_sw_version.startswith("4.6.")
+        and state.local_filesystem.doc_dict
+        and "FSTRATE_ENABLE" in state.local_filesystem.doc_dict
+    ):
+        show_error_message(
+            _("Incompatible parameter definition file detected"),
+            _(
+                "The parameter definition file 'apm.pdef.xml' is incompatible with ArduPilot 4.6.x firmware. "
+                "It appears to be from the master branch. The file will be deleted. "
+                "Please restart the ArduPilot Methodic Configurator."
+            ),
+        )
+        # delete apm.pdef.xml file as it is from master and not from 4.6.x
+        file_path = os.path.join(state.local_filesystem.vehicle_dir, "apm.pdef.xml")
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        sys_exit(1)
+
     # Run component editor workflow
     component_editor(state)
 

ardupilot_methodic_configurator/annotate_params.py

@@ -1,4 +1,4 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 # PYTHON_ARGCOMPLETE_OK
 
 """
@@ -133,7 +133,9 @@ def parse_arguments() -> argparse.Namespace:
     return args
 
 
-def get_xml_data(base_url: str, directory: str, filename: str, vehicle_type: str) -> ET.Element:  # pylint: disable=too-many-locals
+def get_xml_data(  # pylint: disable=too-many-locals, too-many-statements # noqa: PLR0915
+    base_url: str, directory: str, filename: str, vehicle_type: str, fallback_xml_url: Optional[str] = None
+) -> ET.Element:
     """
     Fetches XML data from a local file or a URL.
 
@@ -142,6 +144,7 @@ def get_xml_data(base_url: str, directory: str, filename: str, vehicle_type: str
         directory (str): The directory where the XML file is expected.
         filename (str): The name of the XML file.
         vehicle_type (str): The type of the vehicle.
+        fallback_xml_url (Optional[str]): Fallback URL if the main URL fails.
 
     Returns:
         ET.Element: The root element of the parsed XML data.
@@ -183,19 +186,32 @@ def get_xml_data(base_url: str, directory: str, filename: str, vehicle_type: str
             logging.warning("Unable to fetch XML data: %s", e)
             # Send a GET request to the URL to the fallback (DEV) URL
             try:
-                url = BASE_URL + vehicle_type + "/" + PARAM_DEFINITION_XML_FILE
-                logging.warning("Falling back to the DEV XML file: %s", url)
+                if fallback_xml_url is None:
+                    msg = "No fallback XML URL provided."
+                    raise ValueError(msg) from e
+                url = fallback_xml_url
+                logging.warning("Falling back to the latest stable release XML file: %s", url)
                 response = requests_get(url, timeout=5, proxies=proxies)
                 if response.status_code != 200:
-                    logging.critical("Remote URL: %s", url)
+                    logging.warning("Remote URL: %s", url)
                     msg = f"HTTP status code {response.status_code}"
                     raise requests_exceptions.RequestException(msg)
-            except requests_exceptions.RequestException as exp:
-                logging.critical("Unable to fetch XML data: %s", exp)
-                msg = "Unable to fetch online XML documentation."
-                msg += f"\nDownload it manually from {url} and"
-                msg += f"\nplace it in the {directory} directory"
-                raise SystemExit(msg) from exp
+            except (ValueError, requests_exceptions.RequestException) as ex:
+                logging.warning("Unable to fetch XML data: %s", ex)
+                try:
+                    url = BASE_URL + vehicle_type + "/" + PARAM_DEFINITION_XML_FILE
+                    logging.warning("Falling back to the DEV XML file: %s", url)
+                    response = requests_get(url, timeout=5, proxies=proxies)
+                    if response.status_code != 200:
+                        logging.critical("Remote URL: %s", url)
+                        msg = f"HTTP status code {response.status_code}"
+                        raise requests_exceptions.RequestException(msg)
+                except requests_exceptions.RequestException as exp:
+                    logging.critical("Unable to fetch XML data: %s", exp)
+                    msg = "Unable to fetch online XML documentation."
+                    msg += f"\nDownload it manually from {url} and"
+                    msg += f"\nplace it in the {directory} directory"
+                    raise SystemExit(msg) from exp
         # Get the text content of the response
         xml_data = response.text
         try:
@@ -599,10 +615,29 @@ def get_xml_url(vehicle_type: str, firmware_version: str) -> str:
     return xml_url
 
 
-def parse_parameter_metadata(
-    xml_url: str, xml_dir: str, xml_file: str, vehicle_type: str, max_line_length: int
+def get_fallback_xml_url(vehicle_type: str, firmware_version: str) -> str:
+    vehicle_parm_subdir = {
+        "ArduCopter": "Copter-",
+        "ArduPlane": "Plane-",
+        "Rover": "Rover-",
+        "ArduSub": "Sub-",
+    }
+    try:
+        vehicle_subdir = vehicle_parm_subdir[vehicle_type] + firmware_version[0:3]
+    except KeyError as e:
+        msg = f"Vehicle type '{vehicle_type}' is not supported."
+        raise ValueError(msg) from e
+
+    xml_url = "https://raw.githubusercontent.com/ArduPilot/ParameterRepository/refs/heads/main/"
+    xml_url += vehicle_subdir if firmware_version else vehicle_type
+    xml_url += "/" + PARAM_DEFINITION_XML_FILE
+    return xml_url
+
+
+def parse_parameter_metadata(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+    xml_url: str, xml_dir: str, xml_file: str, vehicle_type: str, max_line_length: int, fallback_xml_url: Optional[str] = None
 ) -> dict[str, Any]:
-    xml_root = get_xml_data(xml_url, xml_dir, xml_file, vehicle_type)
+    xml_root = get_xml_data(xml_url, xml_dir, xml_file, vehicle_type, fallback_xml_url)
     return create_doc_dict(xml_root, vehicle_type, max_line_length)
 
 

ardupilot_methodic_configurator/argparse_check_range.py

@@ -1,7 +1,7 @@
 """
 Check the range of an Argparse parameter.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+This file is part of ArduPilot Methodic Configurator. https://github.com/ArduPilot/MethodicConfigurator
 
 SPDX-FileCopyrightText: 2024 Dmitriy Kovalev
 

ardupilot_methodic_configurator/backend_filesystem.py

@@ -1,7 +1,7 @@
 """
 Filesystem operations.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -38,6 +38,7 @@ from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.annotate_params import (
     PARAM_DEFINITION_XML_FILE,
     format_columns,
+    get_fallback_xml_url,
     get_xml_dir,
     get_xml_url,
     load_default_param_file,
@@ -122,8 +123,11 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
 
         # Read ArduPilot parameter documentation
         xml_url = get_xml_url(vehicle_type, self.fw_version)
+        fallback_xml_url = get_fallback_xml_url(vehicle_type, self.fw_version)
         xml_dir = get_xml_dir(vehicle_dir)
-        self.doc_dict = parse_parameter_metadata(xml_url, xml_dir, PARAM_DEFINITION_XML_FILE, vehicle_type, TOOLTIP_MAX_LENGTH)
+        self.doc_dict = parse_parameter_metadata(
+            xml_url, xml_dir, PARAM_DEFINITION_XML_FILE, vehicle_type, TOOLTIP_MAX_LENGTH, fallback_xml_url
+        )
         self.param_default_dict = load_default_param_file(vehicle_dir)
 
         # Extend parameter documentation metadata if <parameter_file>.pdef.xml exists
@@ -575,7 +579,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 dest = os_path.join(new_vehicle_dir, item)
                 if blank_change_reason and item.endswith(".param"):
                     # Blank the change reason in the template files, strip the comments that start with #
-                    with open(source, encoding="utf-8") as file:
+                    with open(source, encoding="utf-8-sig") as file:
                         lines = file.readlines()
                     with open(dest, "w", encoding="utf-8") as file:
                         file.writelines(line.split("#")[0].strip() + "\n" for line in lines)

ardupilot_methodic_configurator/backend_filesystem_configuration_steps.py

@@ -1,7 +1,7 @@
 """
 Manages configuration steps at the filesystem level.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -10,14 +10,14 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 from json import JSONDecodeError
 from json import load as json_load
-
-# 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 logging import warning as logging_warning
 from os import path as os_path
+from typing import TypedDict
 
+# from sys import exit as sys_exit
+# from logging import debug as logging_debug
 from jsonschema import validate as json_validate
 from jsonschema.exceptions import ValidationError
 
@@ -25,6 +25,26 @@ from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
 
 
+class PhaseData(TypedDict, total=False):
+    """
+    Type definition for configuration phase data.
+
+    Attributes:
+        start: The starting file number for this phase
+        end: The ending file number for this phase (computed)
+        weight: The weight for UI layout proportions (computed)
+        description: Human-readable description of the phase
+        optional: Whether this phase is optional
+
+    """
+
+    start: int
+    end: int
+    weight: int
+    description: str
+    optional: bool
+
+
 class ConfigurationSteps:
     """
     A class to manage configuration steps for the ArduPilot methodic configurator.
@@ -41,7 +61,7 @@ class ConfigurationSteps:
     def __init__(self, _vehicle_dir: str, vehicle_type: str) -> None:
         self.configuration_steps_filename = "configuration_steps_" + vehicle_type + ".json"
         self.configuration_steps: dict[str, dict] = {}
-        self.configuration_phases: dict[str, dict] = {}
+        self.configuration_phases: dict[str, PhaseData] = {}
         self.forced_parameters: dict[str, ParDict] = {}
         self.derived_parameters: dict[str, ParDict] = {}
         self.log_loaded_file = False
@@ -56,7 +76,7 @@ class ConfigurationSteps:
         json_content = {}
         for i, directory in enumerate(search_directories):
             try:
-                with open(os_path.join(directory, self.configuration_steps_filename), encoding="utf-8") as file:
+                with open(os_path.join(directory, self.configuration_steps_filename), encoding="utf-8-sig") as file:
                     json_content = json_load(file)
                     file_found = True
                     if self.log_loaded_file:
@@ -246,3 +266,30 @@ class ConfigurationSteps:
             text = _("No documentation available for {selected_file} in the {self.configuration_steps_filename} file")
             text = documentation.get(tooltip_key, text.format(**locals()))
         return text
+
+    def get_sorted_phases_with_end_and_weight(self, total_files: int) -> dict[str, PhaseData]:
+        """
+        Get sorted phases with added 'end' and 'weight' information.
+
+        Returns phases sorted by start position, with each phase containing:
+        - 'end': The end file number (start of next phase or total_files)
+        - 'weight': Weight for UI layout (max(2, end - start))
+        """
+        active_phases = {k: v for k, v in self.configuration_phases.items() if "start" in v}
+
+        # Sort phases by start position
+        sorted_phases: dict[str, PhaseData] = dict(sorted(active_phases.items(), key=lambda x: x[1].get("start", 0)))
+
+        # Add the end information to each phase using the start of the next phase
+        phase_names = list(sorted_phases.keys())
+        for i, phase_name in enumerate(phase_names):
+            if i < len(phase_names) - 1:
+                next_phase_name = phase_names[i + 1]
+                sorted_phases[phase_name]["end"] = sorted_phases[next_phase_name].get("start", total_files)
+            else:
+                sorted_phases[phase_name]["end"] = total_files
+            phase_start = sorted_phases[phase_name].get("start", 0)
+            phase_end = sorted_phases[phase_name].get("end", total_files)
+            sorted_phases[phase_name]["weight"] = max(2, phase_end - phase_start)
+
+        return sorted_phases

ardupilot_methodic_configurator/backend_filesystem_json_with_schema.py

@@ -1,7 +1,7 @@
 """
 Manages JSON files at the filesystem level.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -46,7 +46,7 @@ class FilesystemJSONWithSchema:
         schema_path = os_path.join(os_path.dirname(__file__), self.schema_filename)
 
         try:
-            with open(schema_path, encoding="utf-8") as file:
+            with open(schema_path, encoding="utf-8-sig") as file:
                 loaded_schema: dict[Any, Any] = json_load(file)
 
                 # Validate the schema itself against the JSON Schema meta-schema
@@ -90,7 +90,7 @@ class FilesystemJSONWithSchema:
         data: dict[Any, Any] = {}
         filepath = os_path.join(data_dir, self.json_filename)
         try:
-            with open(filepath, encoding="utf-8") as file:
+            with open(filepath, encoding="utf-8-sig") as file:
                 data = json_load(file)
 
             # Validate the loaded data against the schema

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -1,7 +1,7 @@
 """
 Manages program settings at the filesystem level.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -9,13 +9,18 @@ SPDX-License-Identifier: GPL-3.0-or-later
 """
 
 # from sys import exit as sys_exit
-import glob
+import subprocess
+from contextlib import suppress as contextlib_suppress
+from glob import glob as glob_glob
 from importlib.resources import files as importlib_files
 from json import dump as json_dump
 from json import load as json_load
 from logging import debug as logging_debug
 from logging import error as logging_error
+from os import chmod as os_chmod
+from os import environ as os_environ
 from os import makedirs as os_makedirs
+from os import name as os_name
 from os import path as os_path
 from os import sep as os_sep
 from pathlib import Path
@@ -23,6 +28,8 @@ from platform import system as platform_system
 from re import escape as re_escape
 from re import match as re_match
 from re import sub as re_sub
+from shutil import which as shutil_which
+from sys import platform as sys_platform
 from typing import Any, Optional, Union
 
 from platformdirs import site_config_dir, user_config_dir
@@ -108,8 +115,18 @@ class ProgramSettings:
 
     @staticmethod
     def application_icon_filepath() -> str:
-        package_path = importlib_files("ardupilot_methodic_configurator")
-        return str(package_path / "images" / "ArduPilot_icon.png")
+        """Get the application icon path, with fallback options."""
+        try:
+            package_path = importlib_files("ardupilot_methodic_configurator")
+        except (ImportError, FileNotFoundError):
+            # Fallback: try to find icon relative to the script
+            package_path = Path(os_path.dirname(os_path.abspath(__file__)))
+
+        icon_path = str(package_path / "images" / "ArduPilot_icon.png")
+        if os_path.exists(icon_path):
+            return icon_path
+        # If no icon found, return empty string (GUI will handle the error)
+        return ""
 
     @staticmethod
     def application_logo_filepath() -> str:
@@ -152,9 +169,12 @@ class ProgramSettings:
     @staticmethod
     def _user_config_dir() -> str:
         user_config_directory = user_config_dir(
-            ".ardupilot_methodic_configurator", appauthor=False, roaming=True, ensure_exists=True
+            ".ardupilot_methodic_configurator", appauthor=False, roaming=True, ensure_exists=False
         )
 
+        if not os_path.exists(user_config_directory):
+            os_makedirs(user_config_directory, exist_ok=True)
+
         if not os_path.exists(user_config_directory):
             error_msg = _("The user configuration directory '{user_config_directory}' does not exist.")
             raise FileNotFoundError(error_msg.format(**locals()))
@@ -167,9 +187,13 @@ class ProgramSettings:
     @staticmethod
     def _site_config_dir() -> str:
         site_config_directory = site_config_dir(
-            ".ardupilot_methodic_configurator", appauthor=False, version=None, multipath=False, ensure_exists=True
+            ".ardupilot_methodic_configurator", appauthor=False, version=None, multipath=False, ensure_exists=False
         )
 
+        if not os_path.exists(site_config_directory):
+            with contextlib_suppress(OSError):
+                os_makedirs(site_config_directory, exist_ok=True)
+
         if not os_path.exists(site_config_directory):
             error_msg = _("The site configuration directory '{site_config_directory}' does not exist.")
             raise FileNotFoundError(error_msg.format(**locals()))
@@ -189,7 +213,7 @@ class ProgramSettings:
 
         """
         try:
-            with open(settings_path, encoding="utf-8") as settings_file:
+            with open(settings_path, encoding="utf-8-sig") as settings_file:
                 loaded_settings: dict[str, Any] = json_load(settings_file)
                 return loaded_settings
         except FileNotFoundError:
@@ -365,7 +389,7 @@ class ProgramSettings:
         filename = f"m_{frame_class:02d}_{frame_type:02d}_*.png"
 
         # Search for matching PNG file (since exact naming varies)
-        matching_files = glob.glob(str(images_dir / filename))
+        matching_files = glob_glob(str(images_dir / filename))
 
         err_msg = (
             ""
@@ -398,3 +422,116 @@ class ProgramSettings:
         """
         filepath, _error_msg = ProgramSettings.motor_diagram_filepath(frame_class, frame_type)
         return filepath != "" and os_path.exists(filepath)
+
+    @staticmethod
+    def _is_linux_system() -> bool:
+        """Check if running on a Linux system."""
+        return os_name == "posix" and sys_platform.startswith("linux")
+
+    @staticmethod
+    def _get_desktop_file_path() -> str:
+        """Get the path where the desktop file should be created."""
+        return os_path.expanduser("~/.local/share/applications/ardupilot_methodic_configurator.desktop")
+
+    @staticmethod
+    def _desktop_icon_exists(desktop_file_path: str) -> bool:
+        """Check if the desktop icon already exists."""
+        return os_path.exists(desktop_file_path)
+
+    @staticmethod
+    def _get_virtual_env_path() -> Optional[str]:
+        """Get the virtual environment path from environment variables."""
+        return os_environ.get("VIRTUAL_ENV")
+
+    @staticmethod
+    def _create_desktop_entry_content(venv_path: str, icon_path: str) -> str:
+        """Create the desktop entry file content."""
+        # Try to use python executable directly for better compatibility
+        python_exe = os_path.join(venv_path, "bin", "python")
+        if os_path.exists(python_exe):
+            # Use python executable directly
+            exec_cmd = f"{python_exe} -m ardupilot_methodic_configurator"
+        else:
+            # Fallback to bash -c method
+            bash_path = shutil_which("bash") or "/bin/bash"
+            activate_cmd = f"source {venv_path}/bin/activate && ardupilot_methodic_configurator"
+            exec_cmd = f'{bash_path} -c "{activate_cmd}"'
+
+        return f"""[Desktop Entry]
+Version=1.0
+Name=ArduPilot Methodic Configurator
+Comment=A clear ArduPilot configuration sequence
+Exec={exec_cmd}
+Icon={icon_path}
+Terminal=true
+Type=Application
+Categories=Development;
+Keywords=ardupilot;arducopter;drone;parameters;configuration;scm
+"""
+
+    @staticmethod
+    def _ensure_applications_dir_exists(desktop_file_path: str) -> str:
+        """Ensure the applications directory exists and return it."""
+        apps_dir = os_path.dirname(desktop_file_path)
+        os_makedirs(apps_dir, exist_ok=True)
+        return apps_dir
+
+    @staticmethod
+    def _write_desktop_file(desktop_file_path: str, content: str) -> None:
+        """Write the desktop file content to disk."""
+        with open(desktop_file_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    @staticmethod
+    def _set_desktop_file_permissions(desktop_file_path: str) -> None:
+        """Set appropriate permissions on the desktop file."""
+        os_chmod(desktop_file_path, 0o644)
+
+    @staticmethod
+    def _update_desktop_database(apps_dir: str) -> None:
+        """Update the desktop database if the command is available."""
+        update_desktop_db_cmd = shutil_which("update-desktop-database")
+        if update_desktop_db_cmd:
+            subprocess.run([update_desktop_db_cmd, apps_dir], check=False, capture_output=True)  # noqa: S603
+
+    @staticmethod
+    def create_desktop_icon_if_needed() -> None:
+        """
+        Create a desktop icon for the application if running in a virtual environment and icon doesn't exist.
+
+        This function detects if we're running in a virtual environment and creates a desktop
+        entry that activates the venv and runs the application with the correct icon.
+        """
+        # Only create desktop icon on Linux systems
+        if not ProgramSettings._is_linux_system():
+            return
+
+        # Check if desktop icon already exists
+        desktop_file_path = ProgramSettings._get_desktop_file_path()
+        if ProgramSettings._desktop_icon_exists(desktop_file_path):
+            return
+
+        # Check if we're in a virtual environment
+        venv_path = ProgramSettings._get_virtual_env_path()
+        if not venv_path:
+            return
+
+        # Find the icon path
+        icon_path = ProgramSettings.application_icon_filepath()
+        if not icon_path:
+            return
+
+        # Create the desktop entry content
+        desktop_entry = ProgramSettings._create_desktop_entry_content(venv_path, icon_path)
+
+        # Ensure the applications directory exists
+        apps_dir = ProgramSettings._ensure_applications_dir_exists(desktop_file_path)
+
+        # Write the desktop file
+        try:
+            ProgramSettings._write_desktop_file(desktop_file_path, desktop_entry)
+            ProgramSettings._set_desktop_file_permissions(desktop_file_path)
+            ProgramSettings._update_desktop_database(apps_dir)
+
+        except (OSError, subprocess.SubprocessError):
+            logging_error("Failed to create application launch desktop icon")

ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -1,7 +1,7 @@
 """
 Manages vehicle components at the filesystem level.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -99,7 +99,7 @@ class VehicleComponents:
 
         templates = {}
         try:
-            with open(filepath, encoding="utf-8") as file:
+            with open(filepath, encoding="utf-8-sig") as file:
                 templates = json_load(file)
         except FileNotFoundError:
             logging_debug(_("System component templates file '%s' not found."), filepath)
@@ -119,7 +119,7 @@ class VehicleComponents:
 
         templates = {}
         try:
-            with open(filepath, encoding="utf-8") as file:
+            with open(filepath, encoding="utf-8-sig") as file:
                 templates = json_load(file)
         except FileNotFoundError:
             logging_debug(_("User component templates file '%s' not found."), filepath)