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

ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -23,10 +23,10 @@ from os import walk as os_walk
 from re import match as re_match
 from typing import Any, Union
 
-from jsonschema import ValidationError, validate, validators
-
 from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.backend_filesystem_json_with_schema import FilesystemJSONWithSchema
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
+from ardupilot_methodic_configurator.data_model_vehicle_components_json_schema import VehicleComponentsJsonSchema
 from ardupilot_methodic_configurator.middleware_template_overview import TemplateOverview
 
 
@@ -34,10 +34,9 @@ class VehicleComponents:
     """Load and save vehicle components configurations from a JSON file."""
 
     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[str, Any]] = None
-        self.schema: Union[None, dict[Any, Any]] = None
+        self.vehicle_components_fs: FilesystemJSONWithSchema = FilesystemJSONWithSchema(
+            "vehicle_components.json", "vehicle_components_schema.json"
+        )
         self.save_component_to_system_templates = save_component_to_system_templates
 
     def load_schema(self) -> dict:
@@ -46,35 +45,7 @@ class VehicleComponents:
 
         :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.vehicle_components_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 {}
+        return self.vehicle_components_fs.load_schema()
 
     def load_component_templates(self) -> dict[str, list[dict]]:
         """
@@ -284,37 +255,12 @@ class VehicleComponents:
         :param data: The vehicle components 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}"
+        return self.vehicle_components_fs.validate_json_against_schema(data)
 
     def load_vehicle_components_json_data(self, vehicle_dir: str) -> dict[Any, Any]:
-        data: dict[Any, Any] = {}
-        filepath = os_path.join(vehicle_dir, self.vehicle_components_json_filename)
-        try:
-            with open(filepath, encoding="utf-8") as file:
-                data = json_load(file)
+        return self.vehicle_components_fs.load_json_data(vehicle_dir)
 
-            # Validate the loaded data against the schema
-            is_valid, error_message = self.validate_vehicle_components(data)
-            if not is_valid:
-                logging_error(_("Invalid vehicle components 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.vehicle_components_json_filename, vehicle_dir)
-        except JSONDecodeError:
-            logging_error(_("Error decoding JSON data from file '%s'."), filepath)
-        self.vehicle_components = data
-        return data
-
-    def save_vehicle_components_json_data(self, data: dict, vehicle_dir: str) -> tuple[bool, str]:  # noqa: PLR0911 # pylint: disable=too-many-return-statements
+    def save_vehicle_components_json_data(self, data: dict, vehicle_dir: str) -> tuple[bool, str]:
         """
         Save the vehicle components data to a JSON file.
 
@@ -322,75 +268,29 @@ class VehicleComponents:
         :param vehicle_dir: The directory to save the file in
         :return: A tuple of (error_occurred, error_message)
         """
-        # Validate before saving
-        # commented out until https://github.com/ArduPilot/MethodicConfigurator/pull/237 gets merged
-        # is_valid, error_message = self.validate_vehicle_components(data)
-        # if not is_valid:
-        #     msg = _("Cannot save invalid vehicle components data: {}").format(error_message)
-        #     logging_error(msg)
-        #     return True, msg
-
-        filepath = os_path.join(vehicle_dir, self.vehicle_components_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(vehicle_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, ""
+        return self.vehicle_components_fs.save_json_data(data, vehicle_dir)
 
     def get_fc_fw_type_from_vehicle_components_json(self) -> str:
-        if self.vehicle_components and "Components" in self.vehicle_components:
-            components = self.vehicle_components["Components"]
-        else:
-            components = None
+        data = self.vehicle_components_fs.data
+        components = data["Components"] if data and "Components" in data else None
         if components:
             fw_type: str = components.get("Flight Controller", {}).get("Firmware", {}).get("Type", "")
             if fw_type in self.supported_vehicles():
                 return fw_type
-            error_msg = _("Firmware type {fw_type} in {self.vehicle_components_json_filename} is not supported")
-            logging_error(error_msg.format(**locals()))
+            error_msg = _("Firmware type {fw_type} in {filename} is not supported")
+            logging_error(error_msg.format(fw_type=fw_type, filename=self.vehicle_components_fs.json_filename))
         return ""
 
     def get_fc_fw_version_from_vehicle_components_json(self) -> str:
-        if self.vehicle_components and "Components" in self.vehicle_components:
-            components = self.vehicle_components["Components"]
-        else:
-            components = None
+        data = self.vehicle_components_fs.data
+        components = data["Components"] if data and "Components" in data else None
         if components:
             version_str: str = components.get("Flight Controller", {}).get("Firmware", {}).get("Version", "")
             version_str = version_str.lstrip().split(" ")[0] if version_str else ""
             if re_match(r"^\d+\.\d+\.\d+$", version_str):
                 return version_str
-            error_msg = _("FW version string {version_str} on {self.vehicle_components_json_filename} is invalid")
-            logging_error(error_msg.format(**locals()))
+            error_msg = _("FW version string {version_str} on {filename} is invalid")
+            logging_error(error_msg.format(version_str=version_str, filename=self.vehicle_components_fs.json_filename))
         return ""
 
     @staticmethod
@@ -409,7 +309,7 @@ class VehicleComponents:
         :return: A dictionary mapping subdirectory paths to TemplateOverview instances.
         """
         vehicle_components_dict = {}
-        file_to_find = VehicleComponents().vehicle_components_json_filename
+        file_to_find = VehicleComponents().vehicle_components_fs.json_filename
         template_default_dir = ProgramSettings.get_templates_base_dir()
         for root, _dirs, files in os_walk(template_default_dir):
             if file_to_find in files:
@@ -436,8 +336,49 @@ class VehicleComponents:
         Preserves the complete structure of the dictionary including all branches and leaves,
         but sets leaf values to empty values based on their type.
         """
-        if self.vehicle_components is not None:
-            self._recursively_clear_dict(self.vehicle_components)
+        data = self.vehicle_components_fs.data
+        if data is not None:
+            self._recursively_clear_dict(data)
+            default_data = {
+                "RC Receiver": {
+                    "FC Connection": {"Type": "RCin/SBUS", "Protocol": "All"},
+                },
+                "Telemetry": {
+                    "FC Connection": {"Type": "SERIAL1", "Protocol": "MAVLink2"},
+                },
+                "Battery Monitor": {
+                    "FC Connection": {"Type": "Analog", "Protocol": "Analog Voltage and Current"},
+                },
+                "Battery": {
+                    "Specifications": {
+                        "Chemistry": "Lipo",
+                        "Volt per cell max": 4.2,
+                        "Volt per cell low": 3.6,
+                        "Volt per cell crit": 3.55,
+                    },
+                },
+                "ESC": {
+                    "FC Connection": {"Type": "Main Out", "Protocol": "Normal"},
+                },
+                "Motors": {
+                    "Specifications": {"Poles": 14},
+                },
+                "GNSS Receiver": {
+                    "FC Connection": {"Type": "SERIAL3", "Protocol": "AUTO"},
+                },
+            }
+
+            def is_empty(val: Any) -> bool:
+                return val in (None, "", 0, 0.0, {}) or (isinstance(val, dict) and not val)
+
+            def merge_defaults(target: dict, defaults: dict) -> None:
+                for key, value in defaults.items():
+                    if key not in target or is_empty(target[key]):
+                        target[key] = value
+                    elif isinstance(value, dict) and isinstance(target[key], dict):
+                        merge_defaults(target[key], value)
+
+            merge_defaults(data["Components"], default_data)
 
     def _recursively_clear_dict(self, data: Union[dict, list, float, bool, str]) -> None:
         """
@@ -466,263 +407,11 @@ class VehicleComponents:
             else:
                 data[key] = 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_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", {}):
-            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"]:
-            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]:
-        """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"]:
-            return self._get_component_schema_property_description(current["properties"][section])
-
-        # 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"]:
-                        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"]:
-                    return self._get_component_schema_property_description(allof_item["properties"][section])
-
-        # 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
-        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."""
-        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 get_all_value_datatypes(self) -> dict[str, Any]:
-        """
-        Get a dictionary of all value data types used in the vehicle_components_dict as defined in the schema.
-
-        The keys are the vehicle_components_dict keys and their values are the actual Python datatype
-
-        :return: A nested dictionary mapping data names to their Python datatypes.
-        """
-        schema = self.load_schema()
-        if not schema:
-            return {}
-
-        value_datatypes: dict[str, Any] = {}
-
-        # Start with the Components node since all our editable items are under it
-        components_schema = schema.get("properties", {}).get("Components", {})
-        if not components_schema:
-            return {}
-
-        # Traverse all component types (Flight Controller, Frame, etc.)
-        for component_type, component_schema in components_schema.get("properties", {}).items():
-            value_datatypes[component_type] = {}
-            self._extract_datatypes_from_component(component_schema, value_datatypes[component_type])
-
-        return value_datatypes
-
-    def _extract_datatypes_from_component(self, component_schema: dict[str, Any], target_dict: dict[str, Any]) -> None:
-        """Extract datatypes from a component schema recursively."""
-        # Resolve reference if present
-        resolved_schema = self._resolve_schema_reference(component_schema)
-
-        # Check direct properties
-        if "properties" in resolved_schema:
-            for prop_name, prop_schema in resolved_schema["properties"].items():
-                self._extract_datatypes_from_property(prop_schema, prop_name, target_dict)
-
-        # Check allOf constructs
-        if "allOf" in resolved_schema:
-            for allof_item in resolved_schema["allOf"]:
-                self._extract_datatypes_from_component(allof_item, target_dict)
-
-    def _extract_datatypes_from_property(
-        self, prop_schema: dict[str, Any], prop_name: str, target_dict: dict[str, Any]
-    ) -> None:
-        """Extract datatype from a property schema."""
-        # Resolve reference if present
-        resolved_schema = self._resolve_schema_reference(prop_schema)
-
-        # If this property has nested properties, create a nested dict and recurse
-        if "properties" in resolved_schema:
-            target_dict[prop_name] = {}
-            for nested_prop_name, nested_prop_schema in resolved_schema["properties"].items():
-                self._extract_datatypes_from_property(nested_prop_schema, nested_prop_name, target_dict[prop_name])
-
-        # Handle allOf constructs in properties
-        elif "allOf" in resolved_schema:
-            target_dict[prop_name] = {}
-            for allof_item in resolved_schema["allOf"]:
-                self._extract_datatypes_from_property(allof_item, prop_name, target_dict)
-
-        # If this property has a direct type, convert to Python type and record it as a leaf value
-        elif "type" in resolved_schema:
-            target_dict[prop_name] = self._json_type_to_python_type(resolved_schema["type"])
-
-        # If no type or properties found, create empty dict as placeholder
-        else:
-            target_dict[prop_name] = {}
-
-    def _json_type_to_python_type(self, json_type: str) -> type:
-        """
-        Convert JSON Schema type string to actual Python type.
-
-        :param json_type: JSON Schema type string
-        :return: Corresponding Python type
-        """
-        type_mapping = {
-            "string": str,
-            "number": float,
-            "integer": int,
-            "boolean": bool,
-            "array": list,
-            "object": dict,
-            "null": type(None),
-        }
-
-        return type_mapping.get(json_type, str)  # Default to str if unknown type
-
 
 def main() -> None:
     """Main function for standalone execution."""
     vehicle_components = VehicleComponents()
-    vehicle_components.load_schema()
+    schema = VehicleComponentsJsonSchema(vehicle_components.load_schema())
 
     component_property_paths = [
         ("Flight Controller", "Product", "Manufacturer"),
@@ -753,7 +442,7 @@ def main() -> None:
     logging_info("=============================================")
 
     for path in component_property_paths:
-        desc, is_optional = vehicle_components.get_component_property_description(path)
+        desc, is_optional = schema.get_component_property_description(path)
         msg = f"Path: {path}\nDescription: {desc}, Optional: {is_optional}"
         logging_info(msg)
         logging_info("-" * 50)