ardupilot-methodic-configurator 1.4.7__tar.gz → 1.5.0__tar.gz

{ardupilot_methodic_configurator-1.4.7 → ardupilot_methodic_configurator-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ardupilot_methodic_configurator
-Version: 1.4.7
+Version: 1.5.0
 Summary: A clear configuration sequence for ArduPilot vehicles
 Author-email: Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 Maintainer-email: Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
@@ -50,38 +50,37 @@ License-File: LICENSES/PSF-2.0.txt
 License-File: credits/CREDITS.md
 Requires-Dist: argcomplete==3.6.2
 Requires-Dist: defusedxml==0.7.1
-Requires-Dist: jsonschema==4.23.0
+Requires-Dist: jsonschema==4.24.0
 Requires-Dist: matplotlib==3.9.4
 Requires-Dist: numpy==2.0.2
 Requires-Dist: pillow==11.2.1
 Requires-Dist: pip_system_certs==4.0
 Requires-Dist: platformdirs==4.3.8
-Requires-Dist: pymavlink==2.4.43
+Requires-Dist: pymavlink==2.4.47
 Requires-Dist: pyserial==3.5
-Requires-Dist: requests==2.32.3
-Requires-Dist: setuptools==80.7.1
+Requires-Dist: requests==2.32.4
+Requires-Dist: setuptools==80.9.0
 Provides-Extra: dev
-Requires-Dist: coverage==7.8.0; extra == "dev"
+Requires-Dist: coverage==7.8.2; extra == "dev"
 Requires-Dist: mock==5.2.0; extra == "dev"
-Requires-Dist: mypy==1.15.0; extra == "dev"
+Requires-Dist: mypy==1.16.0; extra == "dev"
 Requires-Dist: pre-commit==4.2.0; extra == "dev"
-Requires-Dist: pyinstaller==6.13.0; extra == "dev"
 Requires-Dist: pylint==3.3.7; extra == "dev"
 Requires-Dist: pyright==1.1.400; extra == "dev"
-Requires-Dist: pytest==8.3.5; extra == "dev"
+Requires-Dist: pytest==8.4.0; extra == "dev"
 Requires-Dist: pytest-cov==6.1.1; extra == "dev"
 Requires-Dist: pytest-md==0.2.0; extra == "dev"
-Requires-Dist: pytest-mock==3.14.0; extra == "dev"
+Requires-Dist: pytest-mock==3.14.1; extra == "dev"
 Requires-Dist: python-gettext==5.0; extra == "dev"
-Requires-Dist: ruff==0.11.10; extra == "dev"
-Requires-Dist: types-requests==2.32.0.20250515; extra == "dev"
+Requires-Dist: ruff==0.11.13; extra == "dev"
+Requires-Dist: types-requests==2.32.0.20250602; extra == "dev"
 Provides-Extra: scripts
 Requires-Dist: bs4; extra == "scripts"
 Provides-Extra: win-dist
 Requires-Dist: wheel==0.45.1; extra == "win-dist"
 Requires-Dist: pip==25.1.1; extra == "win-dist"
 Requires-Dist: pywin32==310; extra == "win-dist"
-Requires-Dist: pyinstaller==6.13.0; extra == "win-dist"
+Requires-Dist: pyinstaller==6.14.1; extra == "win-dist"
 Requires-Dist: packaging==25.0; extra == "win-dist"
 Dynamic: license-file
 

{ardupilot_methodic_configurator-1.4.7 → ardupilot_methodic_configurator-1.5.0}/ardupilot_methodic_configurator/__init__.py

@@ -12,4 +12,4 @@ from ardupilot_methodic_configurator.internationalization import load_translatio
 
 _ = load_translation()
 
-__version__ = "1.4.7"
+__version__ = "1.5.0"

{ardupilot_methodic_configurator-1.4.7 → ardupilot_methodic_configurator-1.5.0}/ardupilot_methodic_configurator/backend_filesystem.py

@@ -485,13 +485,15 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         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
 
             for item in os_listdir(template_dir):
                 if item in {

{ardupilot_methodic_configurator-1.4.7 → ardupilot_methodic_configurator-1.5.0}/ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -120,7 +120,7 @@ class ProgramSettings:
         return site_config_directory
 
     @staticmethod
-    def __get_settings_as_dict() -> dict[str, Any]:  # type: ignore[misc]
+    def __get_settings_as_dict() -> dict[str, Any]:
         settings_path = os_path.join(ProgramSettings.__user_config_dir(), "settings.json")
 
         settings = {}
@@ -153,14 +153,14 @@ class ProgramSettings:
         return settings
 
     @staticmethod
-    def __set_settings_from_dict(settings: dict) -> None:  # type: ignore[misc]
+    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]
+    def __get_settings_config() -> tuple[dict[str, Any], str, str]:
         settings = ProgramSettings.__get_settings_as_dict()
 
         # Regular expression pattern to match single backslashes

{ardupilot_methodic_configurator-1.4.7 → ardupilot_methodic_configurator-1.5.0}/ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -36,7 +36,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
 
@@ -631,6 +631,93 @@ class VehicleComponents:
 
         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."""

{ardupilot_methodic_configurator-1.4.7 → ardupilot_methodic_configurator-1.5.0}/ardupilot_methodic_configurator/backend_flightcontroller.py

@@ -525,7 +525,7 @@ class FlightController:
         return self.__create_connection_with_retry(connection_progress_callback)
 
     @staticmethod
-    def __list_serial_ports() -> list[serial.tools.list_ports_common.ListPortInfo]:  # type: ignore[misc]
+    def __list_serial_ports() -> list[serial.tools.list_ports_common.ListPortInfo]:
         """List all available serial ports."""
         comports = serial.tools.list_ports.comports()
         for port in comports:
@@ -555,7 +555,7 @@ class FlightController:
             "*CubePilot*",
             "*Qiotek*",
         ]
-        serial_list = [
+        serial_list: list[mavutil.SerialPort] = [
             mavutil.SerialPort(device=connection[0], description=connection[1])
             for connection in self.__connection_tuples
             if connection[1] and "mavlink" in connection[1].lower()

{ardupilot_methodic_configurator-1.4.7 → ardupilot_methodic_configurator-1.5.0}/ardupilot_methodic_configurator/backend_mavftp.py

@@ -483,9 +483,9 @@ class MAVFTP:  # pylint: disable=too-many-instance-attributes
                     logging.info(" D %s", d[1:])
                 elif d[0] == "F":
                     (name, size) = d[1:].split("\t")
-                    size = int(size)
-                    self.total_size += size
-                    logging.info("   %s\t%u", name, size)
+                    size_int = int(size)
+                    self.total_size += size_int
+                    logging.info("   %s\t%u", name, size_int)
                 else:
                     logging.info(d)
             # ask for more

ardupilot_methodic_configurator-1.5.0/ardupilot_methodic_configurator/data_model_vehicle_components.py

@@ -0,0 +1,21 @@
+"""
+Data model for vehicle components.
+
+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 ardupilot_methodic_configurator.data_model_vehicle_components_import import ComponentDataModelImport
+from ardupilot_methodic_configurator.data_model_vehicle_components_templates import ComponentDataModelTemplates
+from ardupilot_methodic_configurator.data_model_vehicle_components_validation import ComponentDataModelValidation
+
+
+class ComponentDataModel(ComponentDataModelValidation, ComponentDataModelImport, ComponentDataModelTemplates):
+    """
+    Handle vehicle component data operations.
+
+    Combines base data model functionality with FC data import, component template handling and data validation.
+    """

ardupilot_methodic_configurator-1.5.0/ardupilot_methodic_configurator/data_model_vehicle_components_base.py

@@ -0,0 +1,280 @@
+"""
+Data model for vehicle components.
+
+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 logging import debug as logging_debug
+from logging import error as logging_error
+from logging import warning as logging_warning
+from typing import Any, Optional, Union
+
+from ardupilot_methodic_configurator import _, __version__
+from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
+from ardupilot_methodic_configurator.battery_cell_voltages import BatteryCell
+
+# Type aliases to improve code readability
+ComponentPath = tuple[str, ...]
+ComponentData = dict[str, Any]
+ComponentValue = Union[str, int, float]
+ValidationRulePath = tuple[str, str, str]  # Exactly 3 elements for validation rules
+
+
+class ComponentDataModelBase:
+    """
+    A class to handle component data operations separate from UI logic.
+
+    This improves testability by isolating data operations.
+    """
+
+    def __init__(self, initial_data: ComponentData, component_datatypes: dict[str, Any]) -> None:
+        self._data: ComponentData = initial_data if initial_data else {"Components": {}, "Format version": 1}
+        self._battery_chemistry: str = ""
+        self._possible_choices: dict[ValidationRulePath, tuple[str, ...]] = {}
+        self._mot_pwm_types: tuple[str, ...] = ()
+        self._component_datatypes: dict[str, Any] = component_datatypes
+
+    def get_component_data(self) -> ComponentData:
+        """
+        Get the complete component data.
+
+        Only used in pytest code
+        """
+        return self._data
+
+    def get_component_value(self, path: ComponentPath) -> Union[ComponentData, ComponentValue]:
+        """Get a specific component value from the data structure."""
+        data_path = self._data["Components"]
+        for key in path:
+            if key not in data_path:
+                empty_dict: dict[str, Any] = {}
+                return empty_dict
+            data_path = data_path[key]
+
+        # Ensure we return a value that matches our ComponentValue type
+        if isinstance(data_path, (str, int, float, dict)):
+            return data_path
+        # If it's some other type, convert to string
+        return str(data_path)
+
+    def set_component_value(self, path: ComponentPath, value: Union[ComponentData, ComponentValue, None]) -> None:
+        """Set a specific component value in the data structure."""
+        if value is None:
+            value = ""
+
+        # Ensure Components key exists
+        if "Components" not in self._data:
+            self._data["Components"] = {}
+        data_path: ComponentData = self._data["Components"]
+
+        # Navigate to the correct place in the data structure
+        for key in path[:-1]:
+            if key not in data_path:
+                data_path[key] = {}
+            data_path = data_path[key]
+
+        # Update the value using type-safe casting
+        datatype = self._get_component_datatype(path)
+        if datatype:
+            data_path[path[-1]] = self._safe_cast_value(value, datatype, path)
+        else:  # fallback to a less intelligent method
+            # If the component has a specific datatype, use it to process the value
+            data_path[path[-1]] = self._process_value(path, str(value) if value is not None else None)
+
+    def _get_component_datatype(self, path: ComponentPath) -> Optional[type]:
+        """
+        Safely get the Python datatype for a component path from the nested datatypes dictionary.
+
+        Args:
+            path: The component path tuple (e.g., ("Battery", "Specifications", "Capacity mAh"))
+
+        Returns:
+            The Python type if found, None otherwise
+
+        """
+        if not self._component_datatypes or len(path) < 3:
+            return None
+
+        try:
+            component_type = path[0]
+            section = path[1]
+            field = path[2]
+
+            result = self._component_datatypes.get(component_type, {}).get(section, {}).get(field)
+            # Ensure we return a type or None
+            return result if isinstance(result, type) else None
+        except (KeyError, AttributeError, TypeError):
+            return None
+
+    def _safe_cast_value(  # noqa: PLR0911 pylint: disable=too-many-return-statements
+        self, value: Union[ComponentData, ComponentValue, None], datatype: type, path: ComponentPath
+    ) -> Any:  # noqa: ANN401 # Use Any to handle dict/list returns that don't fit ComponentValue
+        """
+        Safely cast a value to the specified datatype with proper error handling.
+
+        Args:
+            value: The value to cast
+            datatype: The target Python type
+            path: The component path for error context
+
+        Returns:
+            The cast value, or falls back to _process_value on error
+
+        """
+        if value is None:
+            # Handle None values based on datatype
+            if datatype is str:
+                return ""
+            if datatype in (int, float):
+                return datatype(0)
+            if datatype is bool:
+                return False
+            if datatype is list:
+                return []
+            if datatype is dict:
+                return {}
+            return ""
+
+        # If already the correct type, return as-is
+        if isinstance(value, datatype):
+            return value
+
+        try:
+            # Special handling for boolean conversion
+            if datatype is bool:
+                if isinstance(value, str):
+                    return value.lower() in ("true", "1", "yes", "on")
+                return bool(value)
+
+            # Special handling for list/dict types
+            if datatype in (list, dict):
+                logging_error(_("Invalid datatype '%s' for path %s"), value, datatype.__name__, path)
+                return ""
+
+            # Standard type conversion
+            return datatype(value)
+
+        except (ValueError, TypeError, AttributeError) as e:
+            # Log the error and fall back to the original processing method
+            logging_warning(_("Failed to cast value '%s' to %s for path %s: %s"), value, datatype.__name__, path, e)
+            return self._process_value(path, str(value) if value is not None else None)
+
+    def _process_value(self, path: ComponentPath, value: Union[str, None]) -> ComponentValue:
+        """Process a string value into the appropriate type based on context."""
+        # Handle None value
+        if value is None:
+            return ""
+
+        # Special handling for Version fields
+        if path[-1] != "Version":
+            try:
+                return int(value)
+            except ValueError:
+                try:
+                    return float(value)
+                except ValueError:
+                    return str(value).strip()
+        return str(value).strip()
+
+    def get_all_components(self) -> ComponentData:
+        """Get all components data."""
+        empty_dict: ComponentData = {}
+        return self._data.get("Components", empty_dict)  # type: ignore[no-any-return]
+
+    def has_components(self) -> bool:
+        """Check if there are any components in the data."""
+        return len(self.get_all_components()) >= 1
+
+    def save_to_filesystem(self, filesystem: LocalFilesystem) -> tuple[bool, str]:
+        """Save component data to filesystem - centralizes save logic."""
+        return filesystem.save_vehicle_components_json_data(self.get_component_data(), filesystem.vehicle_dir)
+
+    def post_init(self, doc_dict: dict) -> None:
+        """Update the data structure to ensure all required fields are present."""
+        self.update_json_structure()
+
+        self.init_possible_choices(doc_dict)
+        self.init_battery_chemistry()
+
+    def update_json_structure(self) -> None:  # pylint: disable=too-many-branches
+        """
+        Update the data structure to ensure all required fields are present.
+
+        Used to update old JSON files to the latest format.
+        """
+        # Get current data
+        data = self._data
+
+        # Ensure the format version is set.
+        if "Format version" not in data:
+            data["Format version"] = 1
+
+        # To update old JSON files that do not have these new fields
+        if "Components" not in data:
+            data["Components"] = {}
+
+        if "Battery" not in data["Components"]:
+            data["Components"]["Battery"] = {}
+
+        if "Specifications" not in data["Components"]["Battery"]:
+            data["Components"]["Battery"]["Specifications"] = {}
+
+        if "Chemistry" not in data["Components"]["Battery"]["Specifications"]:
+            data["Components"]["Battery"]["Specifications"]["Chemistry"] = "Lipo"
+
+        if "Capacity mAh" not in data["Components"]["Battery"]["Specifications"]:
+            data["Components"]["Battery"]["Specifications"]["Capacity mAh"] = 0
+
+        # To update old JSON files that do not have these new "Frame.Specifications.TOW * Kg" fields
+        if "Frame" not in data["Components"]:
+            data["Components"]["Frame"] = {}
+
+        if "Specifications" not in data["Components"]["Frame"]:
+            data["Components"]["Frame"]["Specifications"] = {}
+
+        if "TOW min Kg" not in data["Components"]["Frame"]["Specifications"]:
+            data["Components"]["Frame"]["Specifications"]["TOW min Kg"] = 1
+
+        if "TOW max Kg" not in data["Components"]["Frame"]["Specifications"]:
+            data["Components"]["Frame"]["Specifications"]["TOW max Kg"] = 1
+
+        # Older versions used receiver instead of Receiver, rename it for consistency with other fields
+        if "GNSS receiver" in data["Components"]:
+            data["Components"]["GNSS Receiver"] = data["Components"].pop("GNSS receiver")
+
+        data["Program version"] = __version__
+
+        # To update old JSON files that do not have this new "Flight Controller.Specifications.MCU Series" field
+        if "Flight Controller" not in data["Components"]:
+            data["Components"]["Flight Controller"] = {}
+
+        if "Specifications" not in data["Components"]["Flight Controller"]:
+            fc_data = data["Components"]["Flight Controller"]
+            data["Components"]["Flight Controller"] = {
+                "Product": fc_data.get("Product", {}),
+                "Firmware": fc_data.get("Firmware", {}),
+                "Specifications": {"MCU Series": "Unknown"},
+                "Notes": fc_data.get("Notes", ""),
+            }
+
+        self._data = data
+
+    def init_battery_chemistry(self) -> None:
+        self._battery_chemistry = (
+            self._data.get("Components", {}).get("Battery", {}).get("Specifications", {}).get("Chemistry", "")
+        )
+        if self._battery_chemistry not in BatteryCell.chemistries():
+            logging_error(_("Invalid battery chemistry %s, defaulting to Lipo"), self._battery_chemistry)
+            self._battery_chemistry = "Lipo"
+
+    def init_possible_choices(self, doc_dict: dict[str, Any]) -> None:
+        """Initialize possible choices for validation rules."""
+        # this method should be implemented in the ComponentDataModelValidation mixedin
+
+    def get_combobox_values_for_path(self, path: ValidationRulePath) -> tuple[str, ...]:
+        """Get valid combobox values for a given path."""
+        return self._possible_choices.get(path, ())