|
|
@@ -1,239 +0,0 @@
|
|
|
-#!/usr/bin/env python3
|
|
|
-#
|
|
|
-# This script checks the correctness of the list of visibility settings
|
|
|
-#
|
|
|
-import collections
|
|
|
-import configparser
|
|
|
-import json
|
|
|
-import os
|
|
|
-import sys
|
|
|
-from typing import Any, Dict, List
|
|
|
-
|
|
|
-# Directory where this python file resides
|
|
|
-SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
|
|
|
-
|
|
|
-
|
|
|
-#
|
|
|
-# This class
|
|
|
-#
|
|
|
-class SettingVisibilityInspection:
|
|
|
-
|
|
|
- def __init__(self) -> None:
|
|
|
- # The order of settings type. If the setting is in basic list then it also should be in expert
|
|
|
- self._setting_visibility_order = ["basic", "advanced", "expert"]
|
|
|
-
|
|
|
- # This is dictionary with categories as keys and all setting keys as values.
|
|
|
- self.all_settings_keys = {} # type: Dict[str, List[str]]
|
|
|
-
|
|
|
- # Load all Cura setting keys from the given fdmprinter.json file
|
|
|
- def loadAllCuraSettingKeys(self, fdmprinter_json_path: str) -> None:
|
|
|
- with open(fdmprinter_json_path, "r", encoding = "utf-8") as f:
|
|
|
- json_data = json.load(f)
|
|
|
-
|
|
|
- # Get all settings keys in each category
|
|
|
- for key, data in json_data["settings"].items(): # top level settings are categories
|
|
|
- if "type" in data and data["type"] == "category":
|
|
|
- self.all_settings_keys[key] = []
|
|
|
- self._flattenSettings(data["children"], key) # actual settings are children of top level category-settings
|
|
|
-
|
|
|
- def _flattenSettings(self, settings: Dict[str, str], category: str) -> None:
|
|
|
- for key, setting in settings.items():
|
|
|
- if "type" in setting and setting["type"] != "category":
|
|
|
- self.all_settings_keys[category].append(key)
|
|
|
-
|
|
|
- if "children" in setting:
|
|
|
- self._flattenSettings(setting["children"], category)
|
|
|
-
|
|
|
- # Loads the given setting visibility file and returns a dict with categories as keys and a list of setting keys as
|
|
|
- # values.
|
|
|
- def _loadSettingVisibilityConfigFile(self, file_name: str) -> Dict[str, List[str]]:
|
|
|
- with open(file_name, "r", encoding = "utf-8") as f:
|
|
|
- parser = configparser.ConfigParser(allow_no_value = True)
|
|
|
- parser.read_file(f)
|
|
|
-
|
|
|
- data_dict = {}
|
|
|
- for category, option_dict in parser.items():
|
|
|
- if category in (parser.default_section, "general"):
|
|
|
- continue
|
|
|
-
|
|
|
- data_dict[category] = []
|
|
|
- for key in option_dict:
|
|
|
- data_dict[category].append(key)
|
|
|
-
|
|
|
- return data_dict
|
|
|
-
|
|
|
- def validateSettingsVisibility(self, setting_visibility_files: Dict[str, str]) -> Dict[str, Dict[str, Any]]:
|
|
|
- # First load all setting visibility files into the dict "setting_visibility_dict" in the following structure:
|
|
|
- # <visibility_name> -> <category> -> <list-fo-setting-keys>
|
|
|
- # "basic" -> "info"
|
|
|
- setting_visibility_dict = {} # type: Dict[str, Dict[str, List[str]]]
|
|
|
- for visibility_name, file_path in setting_visibility_files.items():
|
|
|
- setting_visibility_dict[visibility_name] = self._loadSettingVisibilityConfigFile(file_path)
|
|
|
-
|
|
|
- # The result is in the format:
|
|
|
- # <visibility_name> -> dict
|
|
|
- # "basic" -> "file_name": "basic.cfg"
|
|
|
- # "is_valid": True / False
|
|
|
- # "invalid_categories": List[str]
|
|
|
- # "invalid_settings": Dict[category -> List[str]]
|
|
|
- # "missing_categories_from_previous": List[str]
|
|
|
- # "missing_settings_from_previous": Dict[category -> List[str]]
|
|
|
- all_result_dict = dict() # type: Dict[str, Dict[str, Any]]
|
|
|
-
|
|
|
- previous_result = None
|
|
|
- previous_visibility_dict = None
|
|
|
- is_all_valid = True
|
|
|
- for visibility_name in self._setting_visibility_order:
|
|
|
- invalid_categories = []
|
|
|
- invalid_settings = collections.defaultdict(list)
|
|
|
-
|
|
|
- this_visibility_dict = setting_visibility_dict[visibility_name]
|
|
|
- # Check if categories and keys exist at all
|
|
|
- for category, key_list in this_visibility_dict.items():
|
|
|
- if category not in self.all_settings_keys:
|
|
|
- invalid_categories.append(category)
|
|
|
- continue # If this category doesn't exist at all, not need to check for details
|
|
|
-
|
|
|
- for key in key_list:
|
|
|
- if key not in self.all_settings_keys[category]:
|
|
|
- invalid_settings[category].append(key)
|
|
|
-
|
|
|
- is_settings_valid = len(invalid_categories) == 0 and len(invalid_settings) == 0
|
|
|
- file_path = setting_visibility_files[visibility_name]
|
|
|
- result_dict = {"file_name": os.path.basename(file_path),
|
|
|
- "is_valid": is_settings_valid,
|
|
|
- "invalid_categories": invalid_categories,
|
|
|
- "invalid_settings": invalid_settings,
|
|
|
- "missing_categories_from_previous": list(),
|
|
|
- "missing_settings_from_previous": dict(),
|
|
|
- }
|
|
|
-
|
|
|
- # If this is not the first item in the list, check if the settings are defined in the previous
|
|
|
- # visibility file.
|
|
|
- # A visibility with more details SHOULD add more settings. It SHOULD NOT remove any settings defined
|
|
|
- # in the less detailed visibility.
|
|
|
- if previous_visibility_dict is not None:
|
|
|
- missing_categories_from_previous = []
|
|
|
- missing_settings_from_previous = collections.defaultdict(list)
|
|
|
-
|
|
|
- for prev_category, prev_key_list in previous_visibility_dict.items():
|
|
|
- # Skip the categories that are invalid
|
|
|
- if prev_category in previous_result["invalid_categories"]:
|
|
|
- continue
|
|
|
- if prev_category not in this_visibility_dict:
|
|
|
- missing_categories_from_previous.append(prev_category)
|
|
|
- continue
|
|
|
-
|
|
|
- this_key_list = this_visibility_dict[prev_category]
|
|
|
- for key in prev_key_list:
|
|
|
- # Skip the settings that are invalid
|
|
|
- if key in previous_result["invalid_settings"][prev_category]:
|
|
|
- continue
|
|
|
-
|
|
|
- if key not in this_key_list:
|
|
|
- missing_settings_from_previous[prev_category].append(key)
|
|
|
-
|
|
|
- result_dict["missing_categories_from_previous"] = missing_categories_from_previous
|
|
|
- result_dict["missing_settings_from_previous"] = missing_settings_from_previous
|
|
|
- is_settings_valid = len(missing_categories_from_previous) == 0 and len(missing_settings_from_previous) == 0
|
|
|
- result_dict["is_valid"] = result_dict["is_valid"] and is_settings_valid
|
|
|
-
|
|
|
- # Update the complete result dict
|
|
|
- all_result_dict[visibility_name] = result_dict
|
|
|
- previous_result = result_dict
|
|
|
- previous_visibility_dict = this_visibility_dict
|
|
|
-
|
|
|
- is_all_valid = is_all_valid and result_dict["is_valid"]
|
|
|
-
|
|
|
- all_result_dict["all_results"] = {"is_valid": is_all_valid}
|
|
|
-
|
|
|
- return all_result_dict
|
|
|
-
|
|
|
- def printResults(self, all_result_dict: Dict[str, Dict[str, Any]]) -> None:
|
|
|
- print("")
|
|
|
- print("Setting Visibility Check Results:")
|
|
|
-
|
|
|
- prev_visibility_name = None
|
|
|
- for visibility_name in self._setting_visibility_order:
|
|
|
- if visibility_name not in all_result_dict:
|
|
|
- continue
|
|
|
-
|
|
|
- result_dict = all_result_dict[visibility_name]
|
|
|
- print("=============================")
|
|
|
- result_str = "OK" if result_dict["is_valid"] else "INVALID"
|
|
|
- print("[%s] : [%s] : %s" % (visibility_name, result_dict["file_name"], result_str))
|
|
|
-
|
|
|
- if result_dict["is_valid"]:
|
|
|
- continue
|
|
|
-
|
|
|
- # Print details of invalid settings
|
|
|
- if result_dict["invalid_categories"]:
|
|
|
- print("It has the following non-existing CATEGORIES:")
|
|
|
- for category in result_dict["invalid_categories"]:
|
|
|
- print(" - [%s]" % category)
|
|
|
-
|
|
|
- if result_dict["invalid_settings"]:
|
|
|
- print("")
|
|
|
- print("It has the following non-existing SETTINGS:")
|
|
|
- for category, key_list in result_dict["invalid_settings"].items():
|
|
|
- for key in key_list:
|
|
|
- print(" - [%s / %s]" % (category, key))
|
|
|
-
|
|
|
- if prev_visibility_name is not None:
|
|
|
- if result_dict["missing_categories_from_previous"]:
|
|
|
- print("")
|
|
|
- print("The following CATEGORIES are defined in the previous visibility [%s] but not here:" % prev_visibility_name)
|
|
|
- for category in result_dict["missing_categories_from_previous"]:
|
|
|
- print(" - [%s]" % category)
|
|
|
-
|
|
|
- if result_dict["missing_settings_from_previous"]:
|
|
|
- print("")
|
|
|
- print("The following SETTINGS are defined in the previous visibility [%s] but not here:" % prev_visibility_name)
|
|
|
- for category, key_list in result_dict["missing_settings_from_previous"].items():
|
|
|
- for key in key_list:
|
|
|
- print(" - [%s / %s]" % (category, key))
|
|
|
-
|
|
|
- print("")
|
|
|
- prev_visibility_name = visibility_name
|
|
|
-
|
|
|
-
|
|
|
-#
|
|
|
-# Returns a dictionary of setting visibility .CFG files in the given search directory.
|
|
|
-# The dict has the name of the visibility type as the key (such as "basic", "advanced", "expert"), and
|
|
|
-# the actual file path (absolute path).
|
|
|
-#
|
|
|
-def getAllSettingVisiblityFiles(search_dir: str) -> Dict[str, str]:
|
|
|
- visibility_file_dict = dict()
|
|
|
- extension = ".cfg"
|
|
|
- for file_name in os.listdir(search_dir):
|
|
|
- file_path = os.path.join(search_dir, file_name)
|
|
|
-
|
|
|
- # Only check files that has the .cfg extension
|
|
|
- if not os.path.isfile(file_path):
|
|
|
- continue
|
|
|
- if not file_path.endswith(extension):
|
|
|
- continue
|
|
|
-
|
|
|
- base_filename = os.path.basename(file_name)[:-len(extension)]
|
|
|
- visibility_file_dict[base_filename] = file_path
|
|
|
- return visibility_file_dict
|
|
|
-
|
|
|
-
|
|
|
-def main() -> None:
|
|
|
- setting_visibility_files_dir = os.path.abspath(os.path.join(SCRIPT_DIR, "..", "resources", "setting_visibility"))
|
|
|
- fdmprinter_def_path = os.path.abspath(os.path.join(SCRIPT_DIR, "..", "resources", "definitions", "fdmprinter.def.json"))
|
|
|
-
|
|
|
- setting_visibility_files_dict = getAllSettingVisiblityFiles(setting_visibility_files_dir)
|
|
|
-
|
|
|
- inspector = SettingVisibilityInspection()
|
|
|
- inspector.loadAllCuraSettingKeys(fdmprinter_def_path)
|
|
|
-
|
|
|
- check_result = inspector.validateSettingsVisibility(setting_visibility_files_dict)
|
|
|
- is_result_valid = check_result["all_results"]["is_valid"]
|
|
|
- inspector.printResults(check_result)
|
|
|
-
|
|
|
- sys.exit(0 if is_result_valid else 1)
|
|
|
-
|
|
|
-
|
|
|
-if __name__ == "__main__":
|
|
|
- main()
|
Jaime van Kessel