ardupilot-methodic-configurator 1.4.8__py3-none-any.whl → 2.0.0__py3-none-any.whl

ardupilot_methodic_configurator/backend_filesystem.py

@@ -186,6 +186,67 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                         os_rename(old_filename_path, new_filename_path)
                         logging_info("Renamed %s to %s", old_filename, new_filename)
 
+    def _format_columns_sorted_numerically(
+        self, 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 with numeric sorting.
+
+        This is similar to format_columns from annotate_params.py but sorts the values numerically by key.
+
+        Args:
+            values (Dict[str, Any]): The dictionary of values to format.
+            max_width (int, optional): The maximum number of characters on all columns. Default is 105.
+            max_columns (int): Maximum number of columns
+
+        Returns:
+            List[str]: The list of formatted strings.
+
+        """
+        if not values:
+            return []
+
+        # Sort values numerically by key
+        try:
+            # Try to sort by numeric key (int first, then float)
+            try:
+                sorted_items = sorted(values.items(), key=lambda x: int(x[0]))
+            except ValueError:
+                sorted_items = sorted(values.items(), key=lambda x: float(x[0]))
+        except ValueError:
+            # Fall back to string sorting if numeric sorting fails
+            sorted_items = sorted(values.items())
+
+        # Format each key-value pair
+        formatted_items = [f"{key}: {value}" for key, value in sorted_items]
+
+        if not formatted_items:
+            return []
+
+        # Calculate optimal column width and number of columns
+        max_item_length = max(len(item) for item in formatted_items)
+        optimal_columns = min(max_columns, max(1, max_width // (max_item_length + 2)))  # +2 for spacing
+
+        # Ensure we don't exceed max_width with the chosen number of columns
+        while optimal_columns > 1 and (max_item_length + 2) * optimal_columns > max_width:
+            optimal_columns -= 1
+
+        # Arrange items in column-major order
+        num_items = len(formatted_items)
+        rows_per_column = (num_items + optimal_columns - 1) // optimal_columns  # Ceiling division
+
+        result = []
+        for row in range(rows_per_column):
+            row_items = []
+            for col in range(optimal_columns):
+                index = col * rows_per_column + row
+                if index < num_items:
+                    row_items.append(formatted_items[index].ljust(max_item_length))
+            if row_items:
+                result.append("  ".join(row_items).rstrip())
+
+        return result
+
     def __extend_and_reformat_parameter_documentation_metadata(self) -> None:  # pylint: disable=too-many-branches
         for param_name, param_info in self.doc_dict.items():
             if "fields" in param_info:
@@ -239,6 +300,20 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 prefix_parts += [f"Default: {default_value}"]
             param_info["doc_tooltip"] = ("\n").join(prefix_parts)
 
+            # Create a numerically sorted version for Current Value column tooltips
+            prefix_parts_sorted = [
+                f"{param_info['humanName']}",
+            ]
+            prefix_parts_sorted += param_info["documentation"]
+            for key, value in param_info["fields"].items():
+                if key not in {"Units", "UnitText"}:
+                    prefix_parts_sorted += split_into_lines(f"{key}: {value}", TOOLTIP_MAX_LENGTH)
+            prefix_parts_sorted += self._format_columns_sorted_numerically(param_info["values"], TOOLTIP_MAX_LENGTH)
+            if param_name in self.param_default_dict:
+                default_value = format(self.param_default_dict[param_name].value, ".6f").rstrip("0").rstrip(".")
+                prefix_parts_sorted += [f"Default: {default_value}"]
+            param_info["doc_tooltip_sorted_numerically"] = ("\n").join(prefix_parts_sorted)
+
     def read_params_from_files(self) -> dict[str, dict[str, "Par"]]:
         """
         Reads intermediate parameter files from a directory and stores their contents in a dictionary.
@@ -479,28 +554,33 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         return os_path.exists(directory) and os_path.isdir(directory)
 
     def copy_template_files_to_new_vehicle_dir(
-        self, template_dir: str, new_vehicle_dir: str, blank_change_reason: bool
+        self, template_dir: str, new_vehicle_dir: str, blank_change_reason: bool, copy_vehicle_image: bool
     ) -> str:
         # Copy the template files to the new vehicle directory
         try:
             if not os_path.exists(template_dir):
                 error_msg = _("Template directory does not exist: {template_dir}")
+                error_msg = error_msg.format(**locals())
                 logging_error(error_msg)
-                return error_msg.format(**locals())
+                return error_msg
 
             if not os_path.exists(new_vehicle_dir):
                 error_msg = _("New vehicle directory does not exist: {new_vehicle_dir}")
+                error_msg = error_msg.format(**locals())
                 logging_error(error_msg)
-                return error_msg.format(**locals())
+                return error_msg
+
+            skip_files = {
+                "apm.pdef.xml",
+                "last_uploaded_filename.txt",
+                "tempcal_acc.png",
+                "tempcal_gyro.png",
+            }
+            if not copy_vehicle_image:
+                skip_files.add("vehicle.jpg")
 
             for item in os_listdir(template_dir):
-                if item in {
-                    "apm.pdef.xml",
-                    "vehicle.jpg",
-                    "last_uploaded_filename.txt",
-                    "tempcal_acc.png",
-                    "tempcal_gyro.png",
-                }:
+                if item in skip_files:
                     continue
                 source = os_path.join(template_dir, item)
                 dest = os_path.join(new_vehicle_dir, item)
@@ -509,8 +589,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                     with open(source, encoding="utf-8") as file:
                         lines = file.readlines()
                     with open(dest, "w", encoding="utf-8") as file:
-                        for line in lines:
-                            file.write(line.split("#")[0].strip() + "\n")
+                        file.writelines(line.split("#")[0].strip() + "\n" for line in lines)
                 elif os_path.isdir(source):
                     shutil_copytree(source, dest)
                 else:
@@ -600,8 +679,8 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         start_file_index = last_uploaded_index + 1
         if start_file_index >= len(files):
             # Handle the case where last_uploaded_filename is the last file in the list
-            logging_warning(_("Last uploaded file is the last file in the list. Starting from there."))
-            start_file_index = len(files) - 1
+            logging_warning(_("Last uploaded file is the last file in the list. Starting from the beginning."))
+            return start_file
         return files[start_file_index]
 
     def backup_fc_parameters_to_file(
@@ -740,7 +819,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
     def get_git_commit_hash() -> str:
         # Try to get git hash using git command
         try:
-            result = run(  # noqa: S603
+            result = run(
                 ["git", "rev-parse", "HEAD"],  # noqa: S607
                 capture_output=True,
                 text=True,

ardupilot_methodic_configurator/backend_filesystem_json_with_schema.py

@@ -0,0 +1,159 @@
+"""
+Manages JSON files at the filesystem level.
+
+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 json import JSONDecodeError
+from json import dump as json_dump
+from json import load as json_load
+
+# 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 os import path as os_path
+from typing import Any, Union
+
+from jsonschema import ValidationError, validate, validators
+
+from ardupilot_methodic_configurator import _
+
+
+class FilesystemJSONWithSchema:
+    """Load and save data from a JSON file."""
+
+    def __init__(self, json_filename: str, schema_filename: str) -> None:
+        self.json_filename = json_filename
+        self.schema_filename = schema_filename
+        self.data: Union[None, dict[str, Any]] = None
+        self.schema: Union[None, dict[Any, Any]] = None
+
+    def load_schema(self) -> dict:
+        """
+        Load the JSON schema.
+
+        :return: The schema as a dictionary
+        """
+        if self.schema is not None:
+            return self.schema
+
+        # Determine the location of the schema file
+        schema_path = os_path.join(os_path.dirname(__file__), self.schema_filename)
+
+        try:
+            with open(schema_path, encoding="utf-8") as 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)
+        except JSONDecodeError:
+            logging_error(_("Error decoding JSON schema from file '%s'."), schema_path)
+        return {}
+
+    def validate_json_against_schema(self, data: dict) -> tuple[bool, str]:
+        """
+        Validate data against the schema.
+
+        :param data: data to validate
+        :return: A tuple of (is_valid, error_message)
+        """
+        schema = self.load_schema()
+        if not schema:
+            return False, _("Could not load validation schema")
+
+        try:
+            validate(instance=data, schema=schema)
+            return True, ""
+        except ValidationError as e:
+            return False, f"{_('Validation error')}: {e.message}"
+
+    def load_json_data(self, data_dir: str) -> dict[Any, Any]:
+        data: dict[Any, Any] = {}
+        filepath = os_path.join(data_dir, self.json_filename)
+        try:
+            with open(filepath, encoding="utf-8") as file:
+                data = json_load(file)
+
+            # Validate the loaded data against the schema
+            is_valid, error_message = self.validate_json_against_schema(data)
+            if not is_valid:
+                logging_error(_("Invalid JSON file '%s': %s"), filepath, error_message)
+                # We still return the data even if invalid for debugging purposes
+        except FileNotFoundError:
+            # Normal users do not need this information
+            logging_debug(_("File '%s' not found in %s."), self.json_filename, data_dir)
+        except JSONDecodeError:
+            logging_error(_("Error decoding JSON data from file '%s'."), filepath)
+        self.data = data
+        return data
+
+    def save_json_data(self, data: dict, data_dir: str) -> tuple[bool, str]:  # noqa: PLR0911 # pylint: disable=too-many-return-statements
+        """
+        Save the data to a JSON file.
+
+        :param data: The data to save
+        :param data_dir: The directory to save the file in
+        :return: A tuple of (error_occurred, error_message)
+        """
+        # Validate before saving
+
+        is_valid, error_message = self.validate_json_against_schema(data)
+        if not is_valid:
+            msg = _("Cannot save invalid JSON data: {}").format(error_message)
+            logging_error(msg)
+            return True, msg
+
+        filepath = os_path.join(data_dir, self.json_filename)
+        try:
+            with open(filepath, "w", encoding="utf-8", newline="\n") as file:
+                json_dump(data, file, indent=4)
+        except FileNotFoundError:
+            msg = _("Directory '{}' not found").format(data_dir)
+            logging_error(msg)
+            return True, msg
+        except PermissionError:
+            msg = _("Permission denied when writing to file '{}'").format(filepath)
+            logging_error(msg)
+            return True, msg
+        except IsADirectoryError:
+            msg = _("Path '{}' is a directory, not a file").format(filepath)
+            logging_error(msg)
+            return True, msg
+        except OSError as e:
+            msg = _("OS error when writing to file '{}': {}").format(filepath, str(e))
+            logging_error(msg)
+            return True, msg
+        except TypeError as e:
+            msg = _("Type error when serializing data to JSON: {}").format(str(e))
+            logging_error(msg)
+            return True, msg
+        except ValueError as e:
+            msg = _("Value error when serializing data to JSON: {}").format(str(e))
+            logging_error(msg)
+            return True, msg
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            # Still have a fallback for truly unexpected errors
+            msg = _("Unexpected error saving data to file '{}': {}").format(filepath, str(e))
+            logging_error(msg)
+            return True, msg
+
+        return False, ""