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

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -8,10 +8,11 @@ SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 SPDX-License-Identifier: GPL-3.0-or-later
 """
 
+# from sys import exit as sys_exit
+import glob
+import sys
 from json import dump as json_dump
 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 os import makedirs as os_makedirs
@@ -21,18 +22,12 @@ 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 typing import Any, Union
+from typing import Any, Optional, Union
 
 from platformdirs import site_config_dir, user_config_dir
 
 from ardupilot_methodic_configurator import _
 
-SETTINGS_DEFAULTS: dict[str, Union[int, bool]] = {
-    "Format version": 1,
-    "auto_open_doc_in_browser": True,
-    "annotate_docs_into_param_files": False,
-}
-
 
 class ProgramSettings:
     """
@@ -46,15 +41,76 @@ class ProgramSettings:
     def __init__(self) -> None:
         pass
 
+    @classmethod
+    def _get_settings_defaults(cls) -> dict[str, Union[int, bool, str, float, dict]]:
+        """
+        Get the default settings dictionary with dynamically computed paths.
+
+        Returns:
+            dict: Default settings with all paths properly computed
+
+        """
+        # Define default settings directly - no need for deep copying
+        settings_directory = cls._user_config_dir()
+
+        return {
+            "Format version": 1,
+            "display_usage_popup": {
+                "component_editor": True,
+                "parameter_editor": True,
+            },
+            "directory_selection": {
+                "template_dir": os_path.join(cls.get_templates_base_dir(), "ArduCopter", "diatone_taycan_mxc", "4.5.x-params"),
+                "new_base_dir": os_path.join(settings_directory, "vehicles"),
+                "vehicle_dir": os_path.join(settings_directory, "vehicles"),
+            },
+            "auto_open_doc_in_browser": True,
+            "annotate_docs_into_param_files": False,
+            "gui_complexity": "simple",  # simple or normal
+            # Motor test settings
+            "motor_test_duration": 2.5,  # Default test duration in seconds
+            "motor_test_throttle_pct": 10,  # Default throttle percentage (10%)
+        }
+
+    @staticmethod
+    def _recursive_merge_defaults(settings: dict[str, Any], defaults: dict[str, Any]) -> dict[str, Any]:
+        """
+        Recursively merge default values into settings dictionary.
+
+        This handles nested dictionaries properly and is much cleaner than manual checking.
+
+        Args:
+            settings: Existing settings dictionary
+            defaults: Default values to merge in
+
+        Returns:
+            dict: Settings with all defaults applied
+
+        """
+        for key, default_value in defaults.items():
+            if key not in settings:
+                settings[key] = default_value
+            elif isinstance(default_value, dict) and isinstance(settings[key], dict):
+                # Recursively merge nested dictionaries
+                settings[key] = ProgramSettings._recursive_merge_defaults(settings[key], default_value)
+        return settings
+
+    @staticmethod
+    def _get_settings_as_dict() -> dict[str, Any]:
+        settings_path = os_path.join(ProgramSettings._user_config_dir(), "settings.json")
+        settings = ProgramSettings._load_settings_from_file(settings_path)
+        # fallback to default values if settings are not defined in the json file
+        return ProgramSettings._recursive_merge_defaults(settings, ProgramSettings._get_settings_defaults())
+
     @staticmethod
     def application_icon_filepath() -> str:
         script_dir = os_path.dirname(os_path.abspath(__file__))
-        return os_path.join(script_dir, "ArduPilot_icon.png")
+        return os_path.join(script_dir, "images", "ArduPilot_icon.png")
 
     @staticmethod
     def application_logo_filepath() -> str:
         script_dir = os_path.dirname(os_path.abspath(__file__))
-        return os_path.join(script_dir, "ArduPilot_logo.png")
+        return os_path.join(script_dir, "images", "ArduPilot_logo.png")
 
     @staticmethod
     def create_new_vehicle_dir(new_vehicle_dir: str) -> str:
@@ -90,7 +146,7 @@ class ProgramSettings:
         return re_match(pattern, dir_name) is not None
 
     @staticmethod
-    def __user_config_dir() -> str:
+    def _user_config_dir() -> str:
         user_config_directory = user_config_dir(
             ".ardupilot_methodic_configurator", appauthor=False, roaming=True, ensure_exists=True
         )
@@ -105,7 +161,7 @@ class ProgramSettings:
         return user_config_directory
 
     @staticmethod
-    def __site_config_dir() -> str:
+    def _site_config_dir() -> str:
         site_config_directory = site_config_dir(
             ".ardupilot_methodic_configurator", appauthor=False, version=None, multipath=False, ensure_exists=True
         )
@@ -120,95 +176,86 @@ class ProgramSettings:
         return site_config_directory
 
     @staticmethod
-    def __get_settings_as_dict() -> dict[str, Any]:  # type: ignore[misc]
-        settings_path = os_path.join(ProgramSettings.__user_config_dir(), "settings.json")
+    def _load_settings_from_file(settings_path: str) -> dict[str, Any]:
+        """
+        Load settings from the specified file path.
 
-        settings = {}
+        Returns:
+            dict: Loaded settings or empty dict if file doesn't exist
 
+        """
         try:
             with open(settings_path, encoding="utf-8") as settings_file:
-                settings = json_load(settings_file)
+                loaded_settings: dict[str, Any] = json_load(settings_file)
+                return loaded_settings
         except FileNotFoundError:
             # If the file does not exist, it will be created later
-            pass
-
-        if "Format version" not in settings:
-            settings["Format version"] = SETTINGS_DEFAULTS["Format version"]
-
-        if "directory_selection" not in settings:
-            settings["directory_selection"] = {}
-
-        if "display_usage_popup" not in settings:
-            settings["display_usage_popup"] = {}
-        if "component_editor" not in settings["display_usage_popup"]:
-            settings["display_usage_popup"]["component_editor"] = True
-        if "parameter_editor" not in settings["display_usage_popup"]:
-            settings["display_usage_popup"]["parameter_editor"] = True
-
-        if "auto_open_doc_in_browser" not in settings:
-            settings["auto_open_doc_in_browser"] = SETTINGS_DEFAULTS["auto_open_doc_in_browser"]
-        if "annotate_docs_into_param_files" not in settings:
-            settings["annotate_docs_into_param_files"] = SETTINGS_DEFAULTS["annotate_docs_into_param_files"]
-
-        return settings
+            return {}
 
     @staticmethod
-    def __set_settings_from_dict(settings: dict) -> None:  # type: ignore[misc]
-        settings_path = os_path.join(ProgramSettings.__user_config_dir(), "settings.json")
+    def _set_settings_from_dict(settings: dict) -> None:
+        settings_path = os_path.join(ProgramSettings._user_config_dir(), "settings.json")
 
         with open(settings_path, "w", encoding="utf-8") as settings_file:
             json_dump(settings, settings_file, indent=4)
 
     @staticmethod
-    def __get_settings_config() -> tuple[dict[str, Any], str, str]:  # type: ignore[misc]
-        settings = ProgramSettings.__get_settings_as_dict()
+    def _normalize_path_separators(path: str) -> str:
+        """
+        Normalize path separators for the current platform.
+
+        Args:
+            path: Path to normalize
 
+        Returns:
+            str: Path with normalized separators
+
+        """
         # Regular expression pattern to match single backslashes
         pattern = r"(?<!\\)\\(?!\\)|(?<!/)/(?!/)"
-
         # Replacement string
         replacement = r"\\" if platform_system() == "Windows" else r"/"
-        return settings, pattern, replacement
+        return re_sub(pattern, replacement, path)
 
     @staticmethod
     def store_recently_used_template_dirs(template_dir: str, new_base_dir: str) -> None:
-        settings, pattern, replacement = ProgramSettings.__get_settings_config()
+        settings = ProgramSettings._get_settings_as_dict()
 
         # Update the settings with the new values
         settings["directory_selection"].update(
             {
-                "template_dir": re_sub(pattern, replacement, template_dir),
-                "new_base_dir": re_sub(pattern, replacement, new_base_dir),
+                "template_dir": ProgramSettings._normalize_path_separators(template_dir),
+                "new_base_dir": ProgramSettings._normalize_path_separators(new_base_dir),
             }
         )
 
-        ProgramSettings.__set_settings_from_dict(settings)
+        ProgramSettings._set_settings_from_dict(settings)
 
     @staticmethod
     def store_template_dir(relative_template_dir: str) -> None:
-        settings, pattern, replacement = ProgramSettings.__get_settings_config()
+        settings = ProgramSettings._get_settings_as_dict()
 
         template_dir = os_path.join(ProgramSettings.get_templates_base_dir(), relative_template_dir)
 
         # Update the settings with the new values
-        settings["directory_selection"].update({"template_dir": re_sub(pattern, replacement, template_dir)})
+        settings["directory_selection"].update({"template_dir": ProgramSettings._normalize_path_separators(template_dir)})
 
-        ProgramSettings.__set_settings_from_dict(settings)
+        ProgramSettings._set_settings_from_dict(settings)
 
     @staticmethod
     def store_recently_used_vehicle_dir(vehicle_dir: str) -> None:
-        settings, pattern, replacement = ProgramSettings.__get_settings_config()
+        settings = ProgramSettings._get_settings_as_dict()
 
         # Update the settings with the new values
-        settings["directory_selection"].update({"vehicle_dir": re_sub(pattern, replacement, vehicle_dir)})
+        settings["directory_selection"].update({"vehicle_dir": ProgramSettings._normalize_path_separators(vehicle_dir)})
 
-        ProgramSettings.__set_settings_from_dict(settings)
+        ProgramSettings._set_settings_from_dict(settings)
 
     @staticmethod
     def get_templates_base_dir() -> str:
         current_script_dir = os_path.dirname(os_path.abspath(__file__))
         if platform_system() == "Windows":
-            site_directory = ProgramSettings.__site_config_dir()
+            site_directory = ProgramSettings._site_config_dir()
         else:
             logging_debug("current script directory: %s", current_script_dir)
             site_directory = current_script_dir
@@ -218,44 +265,138 @@ class ProgramSettings:
 
     @staticmethod
     def get_recently_used_dirs() -> tuple[str, str, str]:
-        template_default_dir = os_path.join(
-            ProgramSettings.get_templates_base_dir(), "ArduCopter", "diatone_taycan_mxc", "4.5.x-params"
-        )
-
-        settings_directory = ProgramSettings.__user_config_dir()
+        settings_directory = ProgramSettings._user_config_dir()
         vehicles_default_dir = os_path.join(settings_directory, "vehicles")
         if not os_path.exists(vehicles_default_dir):
             os_makedirs(vehicles_default_dir, exist_ok=True)
 
-        settings = ProgramSettings.__get_settings_as_dict()
-        template_dir = settings["directory_selection"].get("template_dir", template_default_dir)
-        new_base_dir = settings["directory_selection"].get("new_base_dir", vehicles_default_dir)
-        vehicle_dir = settings["directory_selection"].get("vehicle_dir", vehicles_default_dir)
+        settings = ProgramSettings._get_settings_as_dict()
+        template_dir = settings["directory_selection"].get("template_dir")
+        new_base_dir = settings["directory_selection"].get("new_base_dir")
+        vehicle_dir = settings["directory_selection"].get("vehicle_dir")
 
         return template_dir, new_base_dir, vehicle_dir
 
     @staticmethod
     def display_usage_popup(ptype: str) -> bool:
-        display_usage_popup_settings = ProgramSettings.__get_settings_as_dict().get("display_usage_popup", {})
+        display_usage_popup_settings = ProgramSettings._get_settings_as_dict().get("display_usage_popup", {})
         return bool(display_usage_popup_settings.get(ptype, True))
 
     @staticmethod
     def set_display_usage_popup(ptype: str, value: bool) -> None:
         if ptype in {"component_editor", "parameter_editor"}:
-            settings, _, _ = ProgramSettings.__get_settings_config()
+            settings = ProgramSettings._get_settings_as_dict()
             settings["display_usage_popup"][ptype] = value
-            ProgramSettings.__set_settings_from_dict(settings)
+            ProgramSettings._set_settings_from_dict(settings)
 
     @staticmethod
-    def get_setting(setting: str) -> Union[int, bool]:
-        if setting in SETTINGS_DEFAULTS:
-            setting_default = SETTINGS_DEFAULTS[setting]
-            return ProgramSettings.__get_settings_as_dict().get(setting, setting_default)  # type: ignore[no-any-return]
-        return False
+    def get_setting(setting: str) -> Optional[Union[int, bool, str, float]]:
+        settings = ProgramSettings._get_settings_as_dict()
+        setting_parts = setting.split("/")
+        for part in setting_parts:
+            if part in settings:
+                settings = settings[part]
+            else:
+                logging_error(_("Setting '%s' not found in settings dictionary"), setting)
+                return None
+        if isinstance(settings, (int, bool, str, float)):
+            return settings
+        return None
 
     @staticmethod
-    def set_setting(setting: str, value: Union[int, bool]) -> None:
-        if setting in SETTINGS_DEFAULTS:
-            settings, _, _ = ProgramSettings.__get_settings_config()
+    def set_setting(setting: str, value: Union[bool, str, float]) -> None:
+        settings = ProgramSettings._get_settings_as_dict()
+        setting_parts = setting.split("/")
+
+        # Handle hierarchical setting paths (e.g., "directory_selection/template_dir")
+        if len(setting_parts) > 1:
+            current = settings
+            # Navigate to the nested dictionary, except for the last part
+            for i, part in enumerate(setting_parts[:-1]):
+                if part not in current or not isinstance(current[part], dict):
+                    logging_error(
+                        _("Cannot set nested setting '%s': parent path '%s' not found or not a dictionary"),
+                        setting,
+                        "/".join(setting_parts[: i + 1]),
+                    )
+                    return
+                current = current[part]
+
+            # Set the value at the final level
+            last_part = setting_parts[-1]
+            if last_part in current:
+                current[last_part] = value
+                ProgramSettings._set_settings_from_dict(settings)
+            else:
+                logging_error(_("Setting path '%s' not found in settings dictionary"), setting)
+        # Handle simple (non-hierarchical) setting
+        elif setting in settings:
             settings[setting] = value
-            ProgramSettings.__set_settings_from_dict(settings)
+            ProgramSettings._set_settings_from_dict(settings)
+        else:
+            logging_error(_("Setting '%s' not found in settings dictionary"), setting)
+
+    # Motor Test Settings
+
+    @staticmethod
+    def motor_diagram_filepath(frame_class: int, frame_type: int) -> tuple[str, str]:
+        """
+        Get the filepath for the motor diagram SVG file.
+
+        Args:
+            frame_class: ArduPilot frame class (1=QUAD, 2=HEXA, etc.)
+            frame_type: ArduPilot frame type (0=PLUS, 1=X, etc.)
+
+        Returns:
+            str: Absolute path to the motor diagram SVG file
+            str: Error message if multiple or no files found, empty string if no error
+
+        """
+        # See https://github.com/ArduPilot/ardupilot_wiki/pull/6215
+        # Determine the application directory (where images are stored)
+        if getattr(sys, "frozen", False):
+            # Running as compiled executable
+            application_path = os_path.dirname(sys.executable)
+        else:
+            # Running as script
+            application_path = os_path.dirname(os_path.dirname(os_path.abspath(__file__)))
+
+        images_dir = os_path.join(application_path, "ardupilot_methodic_configurator", "images")
+
+        # Generate SVG filename based on frame configuration
+        filename = f"m_{frame_class:02d}_{frame_type:02d}_*.svg"
+
+        # Search for matching SVG file (since exact naming varies)
+        matching_files = glob.glob(os_path.join(images_dir, filename))
+
+        err_msg = (
+            ""
+            if len(matching_files) == 1
+            else _("Multiple motor diagrams found for class %d and type %d") % (frame_class, frame_type)
+        )
+
+        if matching_files:
+            if err_msg:
+                logging_error(err_msg)
+            return matching_files[0], err_msg  # Return first match
+
+        # If not found, return empty string
+        err_msg = _("Motor diagram not found for class %d and type %d") % (frame_class, frame_type)
+        logging_error(err_msg)
+        return "", err_msg
+
+    @staticmethod
+    def motor_diagram_exists(frame_class: int, frame_type: int) -> bool:
+        """
+        Check if a motor diagram exists for the given frame configuration.
+
+        Args:
+            frame_class: ArduPilot frame class
+            frame_type: ArduPilot frame type
+
+        Returns:
+            bool: True if diagram exists, False otherwise
+
+        """
+        filepath, _error_msg = ProgramSettings.motor_diagram_filepath(frame_class, frame_type)
+        return filepath != "" and os_path.exists(filepath)

ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -27,6 +27,7 @@ from jsonschema import ValidationError, validate, validators
 
 from ardupilot_methodic_configurator import _
 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
 
 
@@ -36,7 +37,7 @@ class VehicleComponents:
     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.vehicle_components: Union[None, dict[str, Any]] = None
         self.schema: Union[None, dict[Any, Any]] = None
         self.save_component_to_system_templates = save_component_to_system_templates
 
@@ -466,176 +467,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 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"),
@@ -666,7 +502,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)