ardupilot-methodic-configurator 2.1.3__tar.gz → 2.3.0__tar.gz

{ardupilot_methodic_configurator-2.1.3 → ardupilot_methodic_configurator-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ardupilot_methodic_configurator
-Version: 2.1.3
+Version: 2.3.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>
@@ -62,18 +62,18 @@ Requires-Dist: pymavlink==2.4.49
 Requires-Dist: pyserial==3.5
 Requires-Dist: requests==2.32.5
 Provides-Extra: dev
-Requires-Dist: coverage==7.10.6; extra == "dev"
+Requires-Dist: coverage==7.10.7; extra == "dev"
 Requires-Dist: mock==5.2.0; extra == "dev"
-Requires-Dist: mypy==1.18.1; extra == "dev"
+Requires-Dist: mypy==1.18.2; extra == "dev"
 Requires-Dist: pre-commit==4.3.0; extra == "dev"
 Requires-Dist: pylint==3.3.8; extra == "dev"
 Requires-Dist: pyright==1.1.405; extra == "dev"
 Requires-Dist: pytest==8.4.2; extra == "dev"
 Requires-Dist: pytest-cov==7.0.0; extra == "dev"
 Requires-Dist: pytest-md==0.2.0; extra == "dev"
-Requires-Dist: pytest-mock==3.15.0; extra == "dev"
+Requires-Dist: pytest-mock==3.15.1; extra == "dev"
 Requires-Dist: python-gettext==5.0; extra == "dev"
-Requires-Dist: ruff==0.13.0; extra == "dev"
+Requires-Dist: ruff==0.13.1; extra == "dev"
 Requires-Dist: types-requests==2.32.4.20250913; extra == "dev"
 Provides-Extra: scripts
 Requires-Dist: bs4; extra == "scripts"

{ardupilot_methodic_configurator-2.1.3 → ardupilot_methodic_configurator-2.3.0}/ardupilot_methodic_configurator/__init__.py

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

{ardupilot_methodic_configurator-2.1.3 → ardupilot_methodic_configurator-2.3.0}/ardupilot_methodic_configurator/__main__.py

@@ -36,6 +36,7 @@ from ardupilot_methodic_configurator.backend_filesystem_program_settings import
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import verify_and_open_url
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
+from ardupilot_methodic_configurator.configuration_manager import ConfigurationManager
 from ardupilot_methodic_configurator.data_model_par_dict import ParDict
 from ardupilot_methodic_configurator.data_model_software_updates import UpdateManager, check_for_software_updates
 from ardupilot_methodic_configurator.data_model_vehicle_project import VehicleProjectManager
@@ -137,7 +138,7 @@ def connect_to_fc_and_set_vehicle_type(args: argparse.Namespace) -> tuple[Flight
     if error_str:
         if args.device and _("No serial ports found") not in error_str:
             logging_error(error_str)
-        conn_sel_window = ConnectionSelectionWindow(flight_controller, error_str)
+        conn_sel_window = ConnectionSelectionWindow(flight_controller, error_str, default_baudrate=args.baudrate)
         conn_sel_window.root.mainloop()
 
     vehicle_type = args.vehicle_type
@@ -168,8 +169,7 @@ def initialize_flight_controller_and_filesystem(state: ApplicationState) -> None
     # Get default parameter values from flight controller
     if state.flight_controller.master is not None or state.args.device == "test":
         fciw = FlightControllerInfoWindow(state.flight_controller)
-        default_values = fciw.get_param_default_values()
-        state.param_default_values = ParDict(default_values) if default_values else ParDict()
+        state.param_default_values = fciw.get_param_default_values()
 
     # Initialize local filesystem
     try:
@@ -191,7 +191,7 @@ def initialize_flight_controller_and_filesystem(state: ApplicationState) -> None
 
 def vehicle_directory_selection(state: ApplicationState) -> Union[VehicleDirectorySelectionWindow, None]:
     """
-    Handle vehicle directory selection if no parameter files are found.
+    Handle vehicle directory selection if no parameter files are found in the current working directory.
 
     Args:
         state: Application state containing filesystem and flight controller info
@@ -485,7 +485,8 @@ def parameter_editor_and_uploader(state: ApplicationState) -> None:
             )
 
     # Call the GUI function with the starting intermediate parameter file
-    ParameterEditorWindow(start_file, state.flight_controller, state.local_filesystem)
+    configuration_manager = ConfigurationManager(start_file, state.flight_controller, state.local_filesystem)
+    ParameterEditorWindow(configuration_manager)
 
 
 def main() -> None:

{ardupilot_methodic_configurator-2.1.3 → ardupilot_methodic_configurator-2.3.0}/ardupilot_methodic_configurator/backend_filesystem.py

@@ -21,6 +21,7 @@ from os import path as os_path
 from os import remove as os_remove
 from os import rename as os_rename
 from os import rmdir as os_rmdir
+from pathlib import Path
 from platform import system as platform_system
 from re import compile as re_compile
 from shutil import Error as shutil_Error
@@ -135,16 +136,21 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         self.__extend_and_reformat_parameter_documentation_metadata()
 
     def vehicle_configuration_files_exist(self, vehicle_dir: str) -> bool:
-        if os_path.exists(vehicle_dir) and os_path.isdir(vehicle_dir):
-            vehicle_configuration_files = os_listdir(vehicle_dir)
-            if platform_system() == "Windows":
-                vehicle_configuration_files = [f.lower() for f in vehicle_configuration_files]
-            pattern = re_compile(r"^\d{2}_.*\.param$")
-            if self.vehicle_components_fs.json_filename in vehicle_configuration_files and any(
-                pattern.match(f) for f in vehicle_configuration_files
-            ):
-                return True
-        return False
+        vehicle_path = Path(vehicle_dir)
+        if not (vehicle_path.exists() and vehicle_path.is_dir()):
+            return False
+
+        # Use generator expression for better memory efficiency
+        files = (f.name for f in vehicle_path.iterdir() if f.is_file())
+
+        if platform_system() == "Windows":
+            files = (f.lower() for f in files)
+
+        # Convert to set for O(1) lookup performance and compile pattern once
+        file_set = set(files)
+        pattern = re_compile(r"^\d{2}_.*\.param$")
+
+        return self.vehicle_components_fs.json_filename in file_set and any(pattern.match(f) for f in file_set)
 
     def rename_parameter_files(self) -> None:
         if self.vehicle_dir is None or self.configuration_steps is None:
@@ -167,7 +173,7 @@ 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(
+    def _format_columns_sorted_numerically(  # pylint: disable=too-many-locals
         self, values: dict[str, Any], max_width: int = 105, max_columns: int = 4
     ) -> list[str]:
         """
@@ -188,17 +194,19 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
             return []
 
         # Sort values numerically by key
-        try:
-            # Try to sort by numeric key (int first, then float)
+        def sort_key(item: tuple[str, Any]) -> tuple[int, Union[int, float, str]]:
+            key = item[0]
             try:
-                sorted_items = sorted(values.items(), key=lambda x: int(x[0]))
+                return (0, int(key))  # sort integers and floats together
             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())
+                try:
+                    return (0, float(key))  # sort integers and floats together
+                except ValueError:
+                    return (1, str(key))  # Fall back to string sorting and sort them after
 
-        # Format each key-value pair
+        sorted_items = sorted(values.items(), key=sort_key)
+
+        # Format each key-value pair using f-strings
         formatted_items = [f"{key}: {value}" for key, value in sorted_items]
 
         if not formatted_items:
@@ -228,72 +236,94 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
 
         return result
 
-    def __extend_and_reformat_parameter_documentation_metadata(self) -> None:  # pylint: disable=too-many-branches
+    def __extend_and_reformat_parameter_documentation_metadata(self) -> None:
         for param_name, param_info in self.doc_dict.items():
-            if "fields" in param_info:
-                param_fields = param_info["fields"]
-                if "Units" in param_fields:
-                    units_list = param_fields["Units"].split("(")
-                    param_info["unit"] = units_list[0].strip()
-                    if len(units_list) > 1:
-                        param_info["unit_tooltip"] = units_list[1].strip(")").strip()
-                if "Range" in param_fields:
-                    param_info["min"] = float(param_fields["Range"].split(" ")[0].strip())
-                    param_info["max"] = float(param_fields["Range"].split(" ")[1].strip())
-                if "Calibration" in param_fields:
-                    param_info["Calibration"] = self.str_to_bool(param_fields["Calibration"].strip())
-                if "ReadOnly" in param_fields:
-                    param_info["ReadOnly"] = self.str_to_bool(param_fields["ReadOnly"].strip())
-                if "RebootRequired" in param_fields:
-                    param_info["RebootRequired"] = self.str_to_bool(param_fields["RebootRequired"].strip())
-                if "Bitmask" in param_fields:
-                    bitmask_items = param_fields["Bitmask"].split(",")
-                    param_info["Bitmask"] = {}
-                    for item in bitmask_items:
-                        key, value = item.split(":")
-                        param_info["Bitmask"][int(key.strip())] = value.strip()
-
-            if param_info.get("values"):
-                try:
-                    param_info["Values"] = {int(k): v for k, v in param_info["values"].items()}
-                except ValueError:
-                    try:
-                        param_info["Values"] = {float(k): v for k, v in param_info["values"].items()}
-                    except ValueError:
-                        logging_warning(_("Could not convert values to int or float for %s"), param_name)
-                        logging_warning(
-                            _("Parameter %s has invalid metadata. Please file a bug at %s"),
-                            param_name,
-                            "https://github.com/ArduPilot/ardupilot/issues",
-                        )
-                # print(param_info['Values'])
-
-            prefix_parts = [
-                f"{param_info['humanName']}",
-            ]
-            prefix_parts += param_info["documentation"]
-            for key, value in param_info["fields"].items():
-                if key not in {"Units", "UnitText"}:
-                    prefix_parts += split_into_lines(f"{key}: {value}", TOOLTIP_MAX_LENGTH)
-            prefix_parts += format_columns(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 += [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)
+            self._process_parameter_fields(param_info)
+            self._process_parameter_values(param_name, param_info)
+            self._create_parameter_tooltips(param_name, param_info)
+
+    def _process_parameter_fields(self, param_info: dict[str, Any]) -> None:
+        """Process and extract parameter fields like Units, Range, etc."""
+        if "fields" not in param_info:
+            return
+
+        param_fields = param_info["fields"]
+
+        # Process Units
+        if "Units" in param_fields:
+            units_list = param_fields["Units"].split("(")
+            param_info["unit"] = units_list[0].strip()
+            if len(units_list) > 1:
+                param_info["unit_tooltip"] = units_list[1].strip(")").strip()
+
+        # Process Range
+        if "Range" in param_fields:
+            range_parts = param_fields["Range"].split(" ")
+            if len(range_parts) >= 2:
+                param_info["min"] = float(range_parts[0].strip())
+                param_info["max"] = float(range_parts[1].strip())
+
+        # Process boolean fields using dict comprehension for better performance
+        boolean_fields = ["Calibration", "ReadOnly", "RebootRequired"]
+        param_info.update(
+            {
+                field_name: self.str_to_bool(param_fields[field_name].strip())
+                for field_name in boolean_fields
+                if field_name in param_fields
+            }
+        )
+
+        # Process Bitmask using dict comprehension for better performance
+        if "Bitmask" in param_fields:
+            bitmask_items = param_fields["Bitmask"].split(",")
+            param_info["Bitmask"] = {
+                int(key.strip()): value.strip() for item in bitmask_items if ":" in item for key, value in [item.split(":", 1)]
+            }
+
+    def _process_parameter_values(self, param_name: str, param_info: dict[str, Any]) -> None:
+        """Process and convert parameter values to appropriate numeric types."""
+        if not param_info.get("values"):
+            return
+
+        try:
+            param_info["Values"] = {int(k): v for k, v in param_info["values"].items()}
+        except ValueError:
+            try:
+                param_info["Values"] = {float(k): v for k, v in param_info["values"].items()}
+            except ValueError:
+                logging_warning(_("Could not convert values to int or float for %s"), param_name)
+                logging_warning(
+                    _("Parameter %s has invalid metadata. Please file a bug at %s"),
+                    param_name,
+                    "https://github.com/ArduPilot/ardupilot/issues",
+                )
+
+    def _create_parameter_tooltips(self, param_name: str, param_info: dict[str, Any]) -> None:
+        """Create tooltip documentation for parameters."""
+        # Create common prefix parts
+        prefix_parts = [f"{param_info['humanName']}"]
+        prefix_parts += param_info["documentation"]
+
+        # Add field information (excluding Units and UnitText)
+        for key, value in param_info["fields"].items():
+            if key not in {"Units", "UnitText"}:
+                prefix_parts += split_into_lines(f"{key}: {value}", TOOLTIP_MAX_LENGTH)
+
+        # Add default value if available
+        default_suffix = []
+        if param_name in self.param_default_dict:
+            default_value = format(self.param_default_dict[param_name].value, ".6f").rstrip("0").rstrip(".")
+            default_suffix = [f"Default: {default_value}"]
+
+        # Create standard tooltip with alphabetically sorted values
+        prefix_parts_with_values = prefix_parts + format_columns(param_info["values"], TOOLTIP_MAX_LENGTH) + default_suffix
+        param_info["doc_tooltip"] = "\n".join(prefix_parts_with_values)
+
+        # Create numerically sorted tooltip for Current Value column
+        prefix_parts_with_sorted_values = (
+            prefix_parts + self._format_columns_sorted_numerically(param_info["values"], TOOLTIP_MAX_LENGTH) + default_suffix
+        )
+        param_info["doc_tooltip_sorted_numerically"] = "\n".join(prefix_parts_with_sorted_values)
 
     def read_params_from_files(self) -> dict[str, ParDict]:
         """
@@ -336,9 +366,11 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
           Optional[bool]: True, False, or None if the string does not match any known boolean representation.
 
         """
-        if s.lower() == "true" or s.lower() == "yes" or s.lower() == "1":
+        # Use sets for faster O(1) lookup instead of multiple comparisons
+        lower_s = s.lower()
+        if lower_s in {"true", "yes", "1"}:
             return True
-        if s.lower() == "false" or s.lower() == "no" or s.lower() == "0":
+        if lower_s in {"false", "no", "0"}:
             return False
         return None
 
@@ -389,9 +421,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
         """
         ret = {}
         for params in self.file_parameters.values():
-            for param, info in params.items():
-                if info.comment:
-                    ret[param] = info.comment
+            ret.update({param: info.comment for param, info in params.items() if info.comment})
         return ret
 
     def annotate_intermediate_comments_to_param_dict(self, param_dict: dict[str, float]) -> ParDict:
@@ -492,9 +522,9 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
             for file_name in specific_files:
                 self.add_configuration_file_to_zip(zipf, file_name)
 
-            for wrote, filename in files_to_zip:
-                if wrote:
-                    self.add_configuration_file_to_zip(zipf, filename)
+            # Add conditional files using generator expression filtering
+            for filename in (filename for wrote, filename in files_to_zip if wrote):
+                self.add_configuration_file_to_zip(zipf, filename)
 
         logging_info(_("Intermediate parameter files and summary files zipped to %s"), zip_file_path)