diff --git a/kiauh/components/klipper/klipper_utils.py b/kiauh/components/klipper/klipper_utils.py index d85c699..1f161db 100644 --- a/kiauh/components/klipper/klipper_utils.py +++ b/kiauh/components/klipper/klipper_utils.py @@ -174,8 +174,8 @@ def create_example_printer_cfg( return scp = SimpleConfigParser() - scp.read(target) - scp.set("virtual_sdcard", "path", str(instance.base.gcodes_dir)) + scp.read_file(target) + scp.set_option("virtual_sdcard", "path", str(instance.base.gcodes_dir)) # include existing client configs in the example config if clients is not None and len(clients) > 0: @@ -185,7 +185,7 @@ def create_example_printer_cfg( scp.add_section(section=section) create_client_config_symlink(client_config, [instance]) - scp.write(target) + scp.write_file(target) Logger.print_ok(f"Example printer.cfg created in '{instance.base.cfg_dir}'") diff --git a/kiauh/components/moonraker/moonraker.py b/kiauh/components/moonraker/moonraker.py index 0aad053..5130b8e 100644 --- a/kiauh/components/moonraker/moonraker.py +++ b/kiauh/components/moonraker/moonraker.py @@ -138,7 +138,7 @@ class Moonraker: return None scp = SimpleConfigParser() - scp.read(self.cfg_file) + scp.read_file(self.cfg_file) port: int | None = scp.getint("server", "port", fallback=None) return port diff --git a/kiauh/components/moonraker/moonraker_utils.py b/kiauh/components/moonraker/moonraker_utils.py index 42acc81..f23e34b 100644 --- a/kiauh/components/moonraker/moonraker_utils.py +++ b/kiauh/components/moonraker/moonraker_utils.py @@ -77,20 +77,15 @@ def create_example_moonraker_conf( uds = instance.base.comms_dir.joinpath("klippy.sock") scp = SimpleConfigParser() - scp.read(target) + scp.read_file(target) trusted_clients: List[str] = [ - ".".join(ip), - *scp.get("authorization", "trusted_clients"), + f" {'.'.join(ip)}\n", + *scp.getval("authorization", "trusted_clients"), ] - scp.set("server", "port", str(port)) - scp.set("server", "klippy_uds_address", str(uds)) - scp.set( - "authorization", - "trusted_clients", - "\n".join(trusted_clients), - True, - ) + scp.set_option("server", "port", str(port)) + scp.set_option("server", "klippy_uds_address", str(uds)) + scp.set_option("authorization", "trusted_clients", trusted_clients) # add existing client and client configs in the update section if clients is not None and len(clients) > 0: @@ -105,7 +100,7 @@ def create_example_moonraker_conf( ] scp.add_section(section=c_section) for option in c_options: - scp.set(c_section, option[0], option[1]) + scp.set_option(c_section, option[0], option[1]) # client config part c_config = c.client_config @@ -120,9 +115,9 @@ def create_example_moonraker_conf( ] scp.add_section(section=c_config_section) for option in c_config_options: - scp.set(c_config_section, option[0], option[1]) + scp.set_option(c_config_section, option[0], option[1]) - scp.write(target) + scp.write_file(target) Logger.print_ok(f"Example moonraker.conf created in '{instance.base.cfg_dir}'") diff --git a/kiauh/core/menus/remove_menu.py b/kiauh/core/menus/remove_menu.py index 53540d2..005e950 100644 --- a/kiauh/core/menus/remove_menu.py +++ b/kiauh/core/menus/remove_menu.py @@ -45,7 +45,6 @@ class RemoveMenu(BaseMenu): "4": Option(method=self.remove_fluidd), "5": Option(method=self.remove_klipperscreen), "6": Option(method=self.remove_crowsnest), - "7": Option(method=self.remove_octoeverywhere), } def print_menu(self) -> None: diff --git a/kiauh/core/settings/kiauh_settings.py b/kiauh/core/settings/kiauh_settings.py index ff2ac2b..dc5a2ae 100644 --- a/kiauh/core/settings/kiauh_settings.py +++ b/kiauh/core/settings/kiauh_settings.py @@ -53,7 +53,11 @@ class KiauhSettings: return cls._instance def __repr__(self) -> str: - return f"KiauhSettings(kiauh={self.kiauh}, klipper={self.klipper}, moonraker={self.moonraker}, mainsail={self.mainsail}, fluidd={self.fluidd})" + return ( + f"KiauhSettings(kiauh={self.kiauh}, klipper={self.klipper}," + f" moonraker={self.moonraker}, mainsail={self.mainsail}," + f" fluidd={self.fluidd})" + ) def __getitem__(self, item: str) -> Any: return getattr(self, item) @@ -75,8 +79,8 @@ class KiauhSettings: def get(self, section: str, option: str) -> str | int | bool: """ - Get a value from the settings state by providing the section and option name as strings. - Prefer direct access to the properties, as it is usually safer! + Get a value from the settings state by providing the section and option name as + strings. Prefer direct access to the properties, as it is usually safer! :param section: The section name as string. :param option: The option name as string. :return: The value of the option as string, int or bool. @@ -91,7 +95,7 @@ class KiauhSettings: def save(self) -> None: self._set_config_options_state() - self.config.write(CUSTOM_CFG) + self.config.write_file(CUSTOM_CFG) self._load_config() def _load_config(self) -> None: @@ -99,7 +103,7 @@ class KiauhSettings: self._kill() cfg = CUSTOM_CFG if CUSTOM_CFG.exists() else DEFAULT_CFG - self.config.read(cfg) + self.config.read_file(cfg) self._validate_cfg() self._apply_settings_from_file() @@ -132,7 +136,7 @@ class KiauhSettings: def _validate_bool(self, section: str, option: str) -> None: self._v_section, self._v_option = (section, option) - bool(self.config.getboolean(section, option)) + (bool(self.config.getboolean(section, option))) def _validate_int(self, section: str, option: str) -> None: self._v_section, self._v_option = (section, option) @@ -140,7 +144,7 @@ class KiauhSettings: def _validate_str(self, section: str, option: str) -> None: self._v_section, self._v_option = (section, option) - v = self.config.get(section, option) + v = self.config.getval(section, option) if v.isdigit() or v.lower() == "true" or v.lower() == "false": raise ValueError @@ -148,10 +152,10 @@ class KiauhSettings: self.kiauh.backup_before_update = self.config.getboolean( "kiauh", "backup_before_update" ) - self.klipper.repo_url = self.config.get("klipper", "repo_url") - self.klipper.branch = self.config.get("klipper", "branch") - self.moonraker.repo_url = self.config.get("moonraker", "repo_url") - self.moonraker.branch = self.config.get("moonraker", "branch") + self.klipper.repo_url = self.config.getval("klipper", "repo_url") + self.klipper.branch = self.config.getval("klipper", "branch") + self.moonraker.repo_url = self.config.getval("moonraker", "repo_url") + self.moonraker.branch = self.config.getval("moonraker", "branch") self.mainsail.port = self.config.getint("mainsail", "port") self.mainsail.unstable_releases = self.config.getboolean( "mainsail", "unstable_releases" @@ -162,23 +166,23 @@ class KiauhSettings: ) def _set_config_options_state(self) -> None: - self.config.set( + self.config.set_option( "kiauh", "backup_before_update", str(self.kiauh.backup_before_update), ) - self.config.set("klipper", "repo_url", self.klipper.repo_url) - self.config.set("klipper", "branch", self.klipper.branch) - self.config.set("moonraker", "repo_url", self.moonraker.repo_url) - self.config.set("moonraker", "branch", self.moonraker.branch) - self.config.set("mainsail", "port", str(self.mainsail.port)) - self.config.set( + self.config.set_option("klipper", "repo_url", self.klipper.repo_url) + self.config.set_option("klipper", "branch", self.klipper.branch) + self.config.set_option("moonraker", "repo_url", self.moonraker.repo_url) + self.config.set_option("moonraker", "branch", self.moonraker.branch) + self.config.set_option("mainsail", "port", str(self.mainsail.port)) + self.config.set_option( "mainsail", "unstable_releases", str(self.mainsail.unstable_releases), ) - self.config.set("fluidd", "port", str(self.fluidd.port)) - self.config.set( + self.config.set_option("fluidd", "port", str(self.fluidd.port)) + self.config.set_option( "fluidd", "unstable_releases", str(self.fluidd.unstable_releases) ) diff --git a/kiauh/core/submodules/simple_config_parser/src/simple_config_parser/constants.py b/kiauh/core/submodules/simple_config_parser/src/simple_config_parser/constants.py new file mode 100644 index 0000000..445e102 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/src/simple_config_parser/constants.py @@ -0,0 +1,62 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +import re + +# definition of section line: +# - then line MUST start with an opening square bracket - it is the first section marker +# - the section marker MUST be followed by at least one character - it is the section name +# - the section name MUST be followed by a closing square bracket - it is the second section marker +# - the second section marker MAY be followed by any amount of whitespace characters +# - the second section marker MAY be followed by a # or ; - it is the comment marker +# - the inline comment MAY be of any length and character +SECTION_RE = re.compile(r"^\[(\S.*\S|\S)]\s*([#;].*)?$") + +# definition of option line: +# - the line MUST start with a word - it is the option name +# - the option name MUST be followed by a colon or an equal sign - it is the separator +# - the separator MUST be followed by a value +# - the separator MAY have any amount of leading or trailing whitespaces +# - the separator MUST NOT be directly followed by a colon or equal sign +# - the value MAY be of any length and character +# - the value MAY contain any amount of trailing whitespaces +# - the value MAY be followed by a # or ; - it is the comment marker +# - the inline comment MAY be of any length and character +OPTION_RE = re.compile(r"^([^;#:=\s]+)\s?[:=]\s*([^;#:=\s][^;#]*?)\s*([#;].*)?$") +# definition of options block start line: +# - the line MUST start with a word - it is the option name +# - the option name MUST be followed by a colon or an equal sign - it is the separator +# - the separator MUST NOT be followed by a value +# - the separator MAY have any amount of leading or trailing whitespaces +# - the separator MUST NOT be directly followed by a colon or equal sign +# - the separator MAY be followed by a # or ; - it is the comment marker +# - the inline comment MAY be of any length and character +OPTIONS_BLOCK_START_RE = re.compile(r"^([^;#:=\s]+)\s*[:=]\s*([#;].*)?$") + +# definition of comment line: +# - the line MAY start with any amount of whitespace characters +# - the line MUST contain a # or ; - it is the comment marker +# - the comment marker MAY be followed by any amount of whitespace characters +# - the comment MAY be of any length and character +LINE_COMMENT_RE = re.compile(r"^\s*[#;].*") + +# definition of empty line: +# - the line MUST contain only whitespace characters +EMPTY_LINE_RE = re.compile(r"^\s*$") + +BOOLEAN_STATES = { + "1": True, + "yes": True, + "true": True, + "on": True, + "0": False, + "no": False, + "false": False, + "off": False, +} + +HEADER_IDENT = "#_header" diff --git a/kiauh/core/submodules/simple_config_parser/src/simple_config_parser/simple_config_parser.py b/kiauh/core/submodules/simple_config_parser/src/simple_config_parser/simple_config_parser.py index b2246bb..88f2ae0 100644 --- a/kiauh/core/submodules/simple_config_parser/src/simple_config_parser/simple_config_parser.py +++ b/kiauh/core/submodules/simple_config_parser/src/simple_config_parser/simple_config_parser.py @@ -1,5 +1,5 @@ # ======================================================================= # -# Copyright (C) 2020 - 2024 Dominik Willner # +# Copyright (C) 2024 Dominik Willner # # # # https://github.com/dw-0/simple-config-parser # # # @@ -8,47 +8,24 @@ from __future__ import annotations -import re +import secrets +import string from pathlib import Path -from typing import Callable, Dict, List, Match, Tuple, TypedDict +from typing import Callable, Dict, List + +from ..simple_config_parser.constants import ( + BOOLEAN_STATES, + EMPTY_LINE_RE, + HEADER_IDENT, + LINE_COMMENT_RE, + OPTION_RE, + OPTIONS_BLOCK_START_RE, + SECTION_RE, +) _UNSET = object() -class Section(TypedDict): - """ - A single section in the config file - - - _raw: The raw representation of the section name - - options: A list of options in the section - """ - - _raw: str - options: List[Option] - - -class Option(TypedDict, total=False): - """ - A single option in a section in the config file - - - is_multiline: Whether the option is a multiline option - - option: The name of the option - - value: The value of the option - - _raw: The raw representation of the option - - _raw_value: The raw value of the option - - A multinline option is an option that contains multiple lines of text following - the option name in the next line. The value of a multiline option is a list of - strings, where each string represents a single line of text. - """ - - is_multiline: bool - option: str - value: str | List[str] - _raw: str - _raw_value: str | List[str] - - class NoSectionError(Exception): """Raised when a section is not defined""" @@ -57,14 +34,6 @@ class NoSectionError(Exception): super().__init__(msg) -class NoOptionError(Exception): - """Raised when an option is not defined in a section""" - - def __init__(self, option: str, section: str): - msg = f"Option '{option}' in section '{section}' is not defined" - super().__init__(msg) - - class DuplicateSectionError(Exception): """Raised when a section is defined more than once""" @@ -73,11 +42,11 @@ class DuplicateSectionError(Exception): super().__init__(msg) -class DuplicateOptionError(Exception): - """Raised when an option is defined more than once""" +class NoOptionError(Exception): + """Raised when an option is not defined in a section""" def __init__(self, option: str, section: str): - msg = f"Option '{option}' in section '{section}' is defined more than once" + msg = f"Option '{option}' in section '{section}' is not defined" super().__init__(msg) @@ -85,159 +54,195 @@ class DuplicateOptionError(Exception): class SimpleConfigParser: """A customized config parser targeted at handling Klipper style config files""" - # definition of section line: - # - then line MUST start with an opening square bracket - it is the first section marker - # - the section marker MUST be followed by at least one character - it is the section name - # - the section name MUST be followed by a closing square bracket - it is the second section marker - # - the second section marker MAY be followed by any amount of whitespace characters - # - the second section marker MAY be followed by a # or ; - it is the comment marker - # - the inline comment MAY be of any length and character - _SECTION_RE = re.compile(r"\[(.+)]\s*([#;].*)?$") + def __init__(self) -> None: + self.header: List[str] = [] + self.config: Dict = {} + self.current_section: str | None = None + self.current_opt_block: str | None = None + self.current_collector: str | None = None + self.in_option_block: bool = False - # definition of option line: - # - the line MUST start with a word - it is the option name - # - the option name MUST be followed by a colon or an equal sign - it is the separator - # - the separator MUST be followed by a value - # - the separator MAY have any amount of leading or trailing whitespaces - # - the separator MUST NOT be directly followed by a colon or equal sign - # - the value MAY be of any length and character - # - the value MAY contain any amount of trailing whitespaces - # - the value MAY be followed by a # or ; - it is the comment marker - # - the inline comment MAY be of any length and character - _OPTION_RE = re.compile(r"^([^:=\s]+)\s?[:=]\s*([^=:].*)\s*([#;].*)?$") + def _match_section(self, line: str) -> bool: + """Wheter or not the given line matches the definition of a section""" + return SECTION_RE.match(line) is not None - # definition of multiline option line: - # - the line MUST start with a word - it is the option name - # - the option name MUST be followed by a colon or an equal sign - it is the separator - # - the separator MUST NOT be followed by a value - # - the separator MAY have any amount of leading or trailing whitespaces - # - the separator MUST NOT be directly followed by a colon or equal sign - # - the separator MAY be followed by a # or ; - it is the comment marker - # - the inline comment MAY be of any length and character - _MLOPTION_RE = re.compile(r"^([^:=\s]+)\s*[:=]\s*([#;].*)?$") + def _match_option(self, line: str) -> bool: + """Wheter or not the given line matches the definition of an option""" + return OPTION_RE.match(line) is not None - # definition of comment line: - # - the line MAY start with any amount of whitespace characters - # - the line MUST contain a # or ; - it is the comment marker - # - the comment marker MAY be followed by any amount of whitespace characters - # - the comment MAY be of any length and character - _COMMENT_RE = re.compile(r"^\s*([#;].*)?$") + def _match_options_block_start(self, line: str) -> bool: + """Wheter or not the given line matches the definition of a multiline option""" + return OPTIONS_BLOCK_START_RE.match(line) is not None - # definition of empty line: - # - the line MUST contain only whitespace characters - _EMPTY_LINE_RE = re.compile(r"^\s*$") + def _match_line_comment(self, line: str) -> bool: + """Wheter or not the given line matches the definition of a comment""" + return LINE_COMMENT_RE.match(line) is not None - BOOLEAN_STATES = { - "1": True, - "yes": True, - "true": True, - "on": True, - "0": False, - "no": False, - "false": False, - "off": False, - } + def _match_empty_line(self, line: str) -> bool: + """Wheter or not the given line matches the definition of an empty line""" + return EMPTY_LINE_RE.match(line) is not None - def __init__(self): - self._config: Dict = {} - self._header: List[str] = [] - self._all_sections: List[str] = [] - self._all_options: Dict = {} - self.section_name: str = "" - self.in_option_block: bool = False # whether we are in a multiline option block + def _parse_line(self, line: str) -> None: + """Parses a line and determines its type""" + if self._match_section(line): + self.current_collector = None + self.current_opt_block = None + self.current_section = SECTION_RE.match(line).group(1) + self.config[self.current_section] = {"_raw": line} - def read(self, file: Path) -> None: - """ - Read the given file and store the result in the internal state. - Call this method before using any other methods. Calling this method - multiple times will reset the internal state on each call. - """ + elif self._match_option(line): + self.current_collector = None + self.current_opt_block = None + option = OPTION_RE.match(line).group(1) + value = OPTION_RE.match(line).group(2) + self.config[self.current_section][option] = {"_raw": line, "value": value} - self._reset_state() + elif self._match_options_block_start(line): + self.current_collector = None + option = OPTIONS_BLOCK_START_RE.match(line).group(1) + self.current_opt_block = option + self.config[self.current_section][option] = {"_raw": line, "value": []} - try: - with open(file, "r") as f: - self._parse_config(f.readlines()) + elif self.current_opt_block is not None: + self.config[self.current_section][self.current_opt_block]["value"].append( + line + ) - except OSError: - raise + elif self._match_empty_line(line) or self._match_line_comment(line): + self.current_opt_block = None - def _reset_state(self): - """Reset the internal state.""" + # if current_section is None, we are at the beginning of the file, + # so we consider the part up to the first section as the file header + if not self.current_section: + self.config.setdefault(HEADER_IDENT, []).append(line) + else: + section = self.config[self.current_section] - self._config.clear() - self._header.clear() - self._all_sections.clear() - self._all_options.clear() - self.section_name = "" - self.in_option_block = False + # set the current collector to a new value, so that continuous + # empty lines or comments are collected into the same collector + if not self.current_collector: + self.current_collector = self._generate_rand_id() + section[self.current_collector] = [] - def write(self, filename): - """Write the internal state to the given file""" + section[self.current_collector].append(line) - content = self._construct_content() + def read_file(self, file: Path) -> None: + """Read and parse a config file""" + with open(file, "r") as file: + for line in file: + self._parse_line(line) - with open(filename, "w") as f: - f.write(content) + # print(json.dumps(self.config, indent=4)) - def _construct_content(self) -> str: - """ - Constructs the content of the configuration file based on the internal state of - the _config object by iterating over the sections and their options. It starts - by checking if a header is present and extends the content list with its elements. - Then, for each section, it appends the raw representation of the section to the - content list. If the section has a body, it iterates over its options and extends - the content list with their raw representations. If an option is multiline, it - also extends the content list with its raw value. Finally, the content list is - joined into a single string and returned. + def write_file(self, file: Path) -> None: + """Write the current config to the config file""" + if not file: + raise ValueError("No config file specified") - :return: The content of the configuration file as a string - """ - content: List[str] = [] - if self._header is not None: - content.extend(self._header) - for section in self._config: - content.append(self._config[section]["_raw"]) + with open(file, "w") as file: + self._write_header(file) + self._write_sections(file) - if (sec_body := self._config[section].get("body")) is not None: - for option in sec_body: - content.extend(option["_raw"]) - if option["is_multiline"]: - content.extend(option["_raw_value"]) - content: str = "".join(content) + def _write_header(self, file) -> None: + """Write the header to the config file""" + for line in self.config.get(HEADER_IDENT, []): + file.write(line) - return content + def _write_sections(self, file) -> None: + """Write the sections to the config file""" + for section in self.get_sections(): + for key, value in self.config[section].items(): + self._write_section_content(file, key, value) - def sections(self) -> List[str]: - """Return a list of section names""" + def _write_section_content(self, file, key, value) -> None: + """Write the content of a section to the config file""" + if key == "_raw": + file.write(value) + elif key.startswith("#_"): + for line in value: + file.write(line) + elif isinstance(value["value"], list): + file.write(value["_raw"]) + for line in value["value"]: + file.write(line) + else: + file.write(value["_raw"]) - return self._all_sections + def get_sections(self) -> List[str]: + """Return a list of all section names, but exclude any section starting with '#_'""" + return list( + filter( + lambda section: not section.startswith("#_"), + self.config.keys(), + ) + ) + + def has_section(self, section: str) -> bool: + """Check if a section exists""" + return section in self.get_sections() def add_section(self, section: str) -> None: - """Add a new section to the internal state""" - - if section in self._all_sections: + """Add a new section to the config""" + if section in self.get_sections(): raise DuplicateSectionError(section) - self._all_sections.append(section) - self._all_options[section] = {} - self._config[section] = {"_raw": f"\n[{section}]\n", "body": []} + + if len(self.get_sections()) >= 1: + self._check_set_section_spacing() + + self.config[section] = {"_raw": f"[{section}]\n"} + + def _check_set_section_spacing(self): + prev_section = self.get_sections()[-1] + prev_section_content = self.config[prev_section] + last_item = list(prev_section_content.keys())[-1] + if last_item.startswith("#_") and last_item.keys()[-1] != "\n": + prev_section_content[last_item].append("\n") + else: + prev_section_content[self._generate_rand_id()] = ["\n"] def remove_section(self, section: str) -> None: - """Remove the given section""" + """Remove a section from the config""" + self.config.pop(section, None) - if section not in self._all_sections: - raise NoSectionError(section) + def get_options(self, section: str) -> List[str]: + """Return a list of all option names for a given section""" + return list( + filter( + lambda option: option != "_raw" and not option.startswith("#_"), + self.config[section].keys(), + ) + ) - self._all_sections.pop(self._all_sections.index(section)) - self._all_options.pop(section) - self._config.pop(section) + def has_option(self, section: str, option: str) -> bool: + """Check if an option exists in a section""" + return self.has_section(section) and option in self.get_options(section) - def options(self, section) -> List[str]: - """Return a list of option names for the given section name""" + def set_option(self, section: str, option: str, value: str | List[str]) -> None: + """ + Set the value of an option in a section. If the section does not exist, + it is created. If the option does not exist, it is created. + """ + if not self.has_section(section): + self.add_section(section) - return self._all_options.get(section) + if not self.has_option(section, option): + self.config[section][option] = { + "_raw": f"{option}:\n" + if isinstance(value, list) + else f"{option}: {value}\n", + "value": value, + } + else: + opt = self.config[section][option] + if not isinstance(value, list): + opt["_raw"] = opt["_raw"].replace(opt["value"], value) + opt["value"] = value - def get( + def remove_option(self, section: str, option: str) -> None: + """Remove an option from a section""" + self.config[section].pop(option, None) + + def getval( self, section: str, option: str, fallback: str | _UNSET = _UNSET ) -> str | List[str]: """ @@ -246,15 +251,12 @@ class SimpleConfigParser: If the key is not found and 'fallback' is provided, it is used as a fallback value. """ - try: - if section not in self._all_sections: + if section not in self.get_sections(): raise NoSectionError(section) - - if option not in self._all_options.get(section): + if option not in self.get_options(section): raise NoOptionError(option, section) - - return self._all_options[section][option] + return self.config[section][option]["value"] except (NoSectionError, NoOptionError): if fallback is _UNSET: raise @@ -262,25 +264,29 @@ class SimpleConfigParser: def getint(self, section: str, option: str, fallback: int | _UNSET = _UNSET) -> int: """Return the value of the given option in the given section as an int""" - return self._get_conv(section, option, int, fallback=fallback) def getfloat( self, section: str, option: str, fallback: float | _UNSET = _UNSET ) -> float: + """Return the value of the given option in the given section as a float""" return self._get_conv(section, option, float, fallback=fallback) def getboolean( self, section: str, option: str, fallback: bool | _UNSET = _UNSET ) -> bool: + """Return the value of the given option in the given section as a boolean""" return self._get_conv( section, option, self._convert_to_boolean, fallback=fallback ) - def _convert_to_boolean(self, value) -> bool: - if value.lower() not in self.BOOLEAN_STATES: + def _convert_to_boolean(self, value: str) -> bool: + """Convert a string to a boolean""" + if isinstance(value, bool): + return value + if value.lower() not in BOOLEAN_STATES: raise ValueError("Not a boolean: %s" % value) - return self.BOOLEAN_STATES[value.lower()] + return BOOLEAN_STATES[value.lower()] def _get_conv( self, @@ -289,300 +295,18 @@ class SimpleConfigParser: conv: Callable[[str], int | float | bool], fallback: _UNSET = _UNSET, ) -> int | float | bool: + """Return the value of the given option in the given section as a converted value""" try: - return conv(self.get(section, option, fallback)) - except: + return conv(self.getval(section, option, fallback)) + except ValueError as e: if fallback is not _UNSET: return fallback - raise - - def items(self, section: str) -> List[Tuple[str, str]]: - """Return a list of (option, value) tuples for a specific section""" - - if section not in self._all_sections: - raise NoSectionError(section) - - result = [] - for _option in self._all_options[section]: - result.append((_option, self._all_options[section][_option])) - - return result - - def set( - self, - section: str, - option: str, - value: str, - multiline: bool = False, - indent: int = 4, - ) -> None: - """Set the given option to the given value in the given section - - If the option is already defined, it will be overwritten. If the option - is not defined yet, it will be added to the section body. - - The multiline parameter can be used to specify whether the value is - multiline or not. If it is not specified, the value will be considered - as multiline if it contains a newline character. The value will then be split - into multiple lines. If the value does not contain a newline character, it - will be considered as a single line value. The indent parameter can be used - to specify the indentation of the multiline value. Indentations are with spaces. - - :param section: The section to set the option in - :param option: The option to set - :param value: The value to set - :param multiline: Whether the value is multiline or not - :param indent: The indentation for multiline values - """ - - if section not in self._all_sections: - raise NoSectionError(section) - - # prepare the options value and raw value depending on the multiline flag - _raw_value: List[str] | None = None - if multiline or "\n" in value: - _multiline = True - _raw: str = f"{option}:\n" - _value: List[str] = value.split("\n") - _raw_value: List[str] = [f"{' ' * indent}{v}\n" for v in _value] - else: - _multiline = False - _raw: str = f"{option}: {value}\n" - _value: str = value - - # the option does not exist yet - if option not in self._all_options.get(section): - _option: Option = { - "is_multiline": _multiline, - "option": option, - "value": _value, - "_raw": _raw, - } - if _raw_value is not None: - _option["_raw_value"] = _raw_value - self._config[section]["body"].insert(0, _option) - - # the option exists and we need to update it - else: - for _option in self._config[section]["body"]: - if _option["option"] == option: - if multiline: - _option["_raw"] = _raw - else: - # we preserve inline comments by replacing the old value with the new one - _option["_raw"] = _option["_raw"].replace( - _option["value"], _value - ) - _option["value"] = _value - if _raw_value is not None: - _option["_raw_value"] = _raw_value - break - - self._all_options[section][option] = _value - - def remove_option(self, section: str, option: str) -> None: - """Remove the given option from the given section""" - - if section not in self._all_sections: - raise NoSectionError(section) - - if option not in self._all_options.get(section): - raise NoOptionError(option, section) - - for _option in self._config[section]["body"]: - if _option["option"] == option: - del self._all_options[section][option] - self._config[section]["body"].remove(_option) - break - - def has_section(self, section: str) -> bool: - """Return True if the given section exists, False otherwise""" - return section in self._all_sections - - def has_option(self, section: str, option: str) -> bool: - """Return True if the given option exists in the given section, False otherwise""" - return option in self._all_options.get(section) - - def _is_section(self, line: str) -> bool: - """Check if the given line contains a section definition""" - return self._SECTION_RE.match(line) is not None - - def _is_option(self, line: str) -> bool: - """Check if the given line contains an option definition""" - - match: Match[str] | None = self._OPTION_RE.match(line) - - if not match: - return False - - # if there is no value, it's not a regular option but a multiline option - if match.group(2).strip() == "": - return False - - if not match.group(1).strip() == "": - return True - - return False - - def _is_comment(self, line: str) -> bool: - """Check if the given line is a comment""" - return self._COMMENT_RE.match(line) is not None - - def _is_empty_line(self, line: str) -> bool: - """Check if the given line is an empty line""" - return self._EMPTY_LINE_RE.match(line) is not None - - def _is_multiline_option(self, line: str) -> bool: - """Check if the given line starts a multiline option block""" - - match: Match[str] | None = self._MLOPTION_RE.match(line) - - if not match: - return False - - return True - - def _parse_config(self, content: List[str]) -> None: - """Parse the given content and store the result in the internal state""" - - _curr_multi_opt = "" - - # THE ORDER MATTERS, DO NOT REORDER THE CONDITIONS! - for line in content: - if self._is_section(line): - self._parse_section(line) - - elif self._is_option(line): - self._parse_option(line) - - # if it's not a regular option with the value inline, - # it might be a might be a multiline option block - elif self._is_multiline_option(line): - self.in_option_block = True - _curr_multi_opt = self._OPTION_RE.match(line).group(1).strip() - self._add_option_to_section_body(_curr_multi_opt, "", line) - - elif self.in_option_block: - self._parse_multiline_option(_curr_multi_opt, line) - - # if it's nothing from above, it's probably a comment or an empty line - elif self._is_comment(line) or self._is_empty_line(line): - self._parse_comment(line) - - def _parse_section(self, line: str) -> None: - """Parse a section line and store the result in the internal state""" - - match: Match[str] | None = self._SECTION_RE.match(line) - if not match: - return - - self.in_option_block = False - - section_name: str = match.group(1).strip() - self._store_internal_state_section(section_name, line) - - def _store_internal_state_section(self, section: str, raw_value: str) -> None: - """Store the given section and its raw value in the internal state""" - - if section in self._all_sections: - raise DuplicateSectionError(section) - - self.section_name = section - self._all_sections.append(section) - self._all_options[section] = {} - self._config[section]: Section = {"_raw": raw_value, "body": []} - - def _parse_option(self, line: str) -> None: - """Parse an option line and store the result in the internal state""" - - self.in_option_block = False - - match: Match[str] | None = self._OPTION_RE.match(line) - if not match: - return - - option: str = match.group(1).strip() - value: str = match.group(2).strip() - - if ";" in value: - i = value.index(";") - value = value[:i].strip() - elif "#" in value: - i = value.index("#") - value = value[:i].strip() - - self._store_internal_state_option(option, value, line) - - def _store_internal_state_option( - self, option: str, value: str, raw_value: str - ) -> None: - """Store the given option and its raw value in the internal state""" - - section_options = self._all_options.setdefault(self.section_name, {}) - - if option in section_options: - raise DuplicateOptionError(option, self.section_name) - - section_options[option] = value - self._add_option_to_section_body(option, value, raw_value) - - def _parse_multiline_option(self, curr_ml_opt: str, line: str) -> None: - """Parse a multiline option line and store the result in the internal state""" - - section_options = self._all_options.setdefault(self.section_name, {}) - multiline_options = section_options.setdefault(curr_ml_opt, []) - - _cleaned_line = line.strip().strip("\n") - if _cleaned_line and not self._is_comment(line): - multiline_options.append(_cleaned_line) - - # add the option to the internal multiline option value state - self._ensure_section_body_exists() - for _option in self._config[self.section_name]["body"]: - if _option.get("option") == curr_ml_opt: - _option.update( - is_multiline=True, - _raw_value=_option.get("_raw_value", []) + [line], - value=multiline_options, - ) - - def _parse_comment(self, line: str) -> None: - """ - Parse a comment line and store the result in the internal state - - If the there was no previous section parsed, the lines are handled as - the file header and added to the internal header list as it means, that - we are at the very top of the file. - """ - - self.in_option_block = False - - if not self.section_name: - self._header.append(line) - else: - self._add_option_to_section_body("", "", line) - - def _ensure_section_body_exists(self) -> None: - """ - Ensure that the section body exists in the internal state. - If the section body does not exist, it is created as an empty list - """ - if self.section_name not in self._config: - self._config.setdefault(self.section_name, {}).setdefault("body", []) - - def _add_option_to_section_body( - self, option: str, value: str, line: str, is_multiline: bool = False - ) -> None: - """Add a raw option line to the internal state""" - - self._ensure_section_body_exists() - - new_option: Option = { - "is_multiline": is_multiline, - "option": option, - "value": value, - "_raw": line, - } - - option_body = self._config[self.section_name]["body"] - option_body.append(new_option) + raise ValueError( + f"Cannot convert {self.getval(section, option)} to {conv.__name__}" + ) from e + + def _generate_rand_id(self) -> str: + """Generate a random id with 6 characters""" + chars = string.ascii_letters + string.digits + rand_string = "".join(secrets.choice(chars) for _ in range(12)) + return f"#_{rand_string}" diff --git a/kiauh/core/submodules/simple_config_parser/tests/Test SimpleConfigParser.run.xml b/kiauh/core/submodules/simple_config_parser/tests/Test SimpleConfigParser.run.xml deleted file mode 100644 index bc62c5c..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/Test SimpleConfigParser.run.xml +++ /dev/null @@ -1,21 +0,0 @@ - - - - - \ No newline at end of file diff --git a/kiauh/core/submodules/simple_config_parser/tests/assets/klipper_config.txt b/kiauh/core/submodules/simple_config_parser/tests/assets/klipper_config.txt new file mode 100644 index 0000000..383c625 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/assets/klipper_config.txt @@ -0,0 +1,1337 @@ +[mcu] +serial: +baud: 250000 +canbus_uuid: +canbus_interface: +restart_method: +[printer] +kinematics: +max_velocity: +max_accel: +minimum_cruise_ratio: 0.5 +square_corner_velocity: 5.0 +max_accel_to_decel: +[stepper_x] +step_pin: +dir_pin: +enable_pin: +rotation_distance: +microsteps: +full_steps_per_rotation: 200 +gear_ratio: +step_pulse_duration: +endstop_pin: +position_min: 0 +position_endstop: +position_max: +homing_speed: 5.0 +homing_retract_dist: 5.0 +homing_retract_speed: +second_homing_speed: +homing_positive_dir: +[printer] +kinematics: cartesian +max_z_velocity: +max_z_accel: +[stepper_x] +[stepper_y] +[stepper_z] +[printer] +kinematics: delta +max_z_velocity: +max_z_accel: +minimum_z_position: 0 +delta_radius: +print_radius: +[stepper_a] +position_endstop: +arm_length: +angle: +[stepper_b] +[stepper_c] +[delta_calibrate] +radius: +speed: 50 +horizontal_move_z: 5 +[printer] +kinematics: deltesian +max_z_velocity: +max_z_accel: +minimum_z_position: 0 +min_angle: 5 +print_width: +slow_ratio: 3 +[stepper_left] +position_endstop: +arm_length: +arm_x_length: +[stepper_right] +[stepper_y] +[printer] +kinematics: corexy +max_z_velocity: +max_z_accel: +[stepper_x] +[stepper_y] +[stepper_z] +[printer] +kinematics: corexz +max_z_velocity: +max_z_accel: +[stepper_x] +[stepper_y] +[stepper_z] +[printer] +kinematics: hybrid_corexy +max_z_velocity: +max_z_accel: +[stepper_x] +[stepper_y] +[stepper_z] +[printer] +kinematics: hybrid_corexz +max_z_velocity: +max_z_accel: +[stepper_x] +[stepper_y] +[stepper_z] +[printer] +kinematics: polar +max_z_velocity: +max_z_accel: +[stepper_bed] +gear_ratio: +[stepper_arm] +[stepper_z] +[printer] +kinematics: rotary_delta +max_z_velocity: +minimum_z_position: 0 +shoulder_radius: +shoulder_height: +[stepper_a] +gear_ratio: +position_endstop: +upper_arm_length: +lower_arm_length: +angle: +[stepper_b] +[stepper_c] +[delta_calibrate] +radius: +speed: 50 +horizontal_move_z: 5 +[printer] +kinematics: winch +[stepper_a] +rotation_distance: +anchor_x: +anchor_y: +anchor_z: +[printer] +kinematics: none +max_velocity: 1 +max_accel: 1 +[extruder] +step_pin: +dir_pin: +enable_pin: +microsteps: +rotation_distance: +full_steps_per_rotation: +gear_ratio: +nozzle_diameter: +filament_diameter: +max_extrude_cross_section: +instantaneous_corner_velocity: 1.000 +max_extrude_only_distance: 50.0 +max_extrude_only_velocity: +max_extrude_only_accel: +pressure_advance: 0.0 +pressure_advance_smooth_time: 0.040 +heater_pin: +max_power: 1.0 +sensor_type: +sensor_pin: +pullup_resistor: 4700 +smooth_time: 1.0 +control: +pid_Kp: +pid_Ki: +pid_Kd: +max_delta: 2.0 +pwm_cycle_time: 0.100 +min_extrude_temp: 170 +min_temp: +max_temp: +[heater_bed] +heater_pin: +sensor_type: +sensor_pin: +control: +min_temp: +max_temp: +[bed_mesh] +speed: 50 +horizontal_move_z: 5 +mesh_radius: +mesh_origin: +mesh_min: +mesh_max: +probe_count: 3, 3 +round_probe_count: 5 +fade_start: 1.0 +fade_end: 0.0 +fade_target: +split_delta_z: .025 +move_check_distance: 5.0 +mesh_pps: 2, 2 +algorithm: lagrange +bicubic_tension: .2 +zero_reference_position: +faulty_region_1_min: +faulty_region_1_max: +adaptive_margin: +scan_overshoot: +[bed_tilt] +x_adjust: 0 +y_adjust: 0 +z_adjust: 0 +points: +speed: 50 +horizontal_move_z: 5 +[bed_screws] +screw1: +screw1_name: +screw1_fine_adjust: +screw2: +screw2_name: +screw2_fine_adjust: +horizontal_move_z: 5 +probe_height: 0 +speed: 50 +probe_speed: 5 +[screws_tilt_adjust] +screw1: +screw1_name: +screw2: +screw2_name: +speed: 50 +horizontal_move_z: 5 +screw_thread: CW-M3 +[z_tilt] +z_positions: +points: +speed: 50 +horizontal_move_z: 5 +retries: 0 +retry_tolerance: 0 +[quad_gantry_level] +gantry_corners: +points: +speed: 50 +horizontal_move_z: 5 +max_adjust: 4 +retries: 0 +retry_tolerance: 0 +[skew_correction] +[z_thermal_adjust] +temp_coeff: +smooth_time: +z_adjust_off_above: +max_z_adjustment: +sensor_type: +sensor_pin: +min_temp: +max_temp: +gcode_id: +[safe_z_home] +home_xy_position: +speed: 50.0 +z_hop: +z_hop_speed: 15.0 +move_to_previous: False +[homing_override] +gcode: +axes: xyz +set_position_x: +set_position_y: +set_position_z: +[endstop_phase stepper_z] +endstop_accuracy: +trigger_phase: +endstop_align_zero: False +[gcode_macro my_cmd] +gcode: +variable_: +rename_existing: +description: G-Code macro +[delayed_gcode my_delayed_gcode] +gcode: +initial_duration: 0.0 +[save_variables] +filename: +[idle_timeout] +gcode: +timeout: 600 +[virtual_sdcard] +path: +on_error_gcode: +[sdcard_loop] +[force_move] +enable_force_move: False +[pause_resume] +recover_velocity: 50. +[firmware_retraction] +retract_length: 0 +retract_speed: 20 +unretract_extra_length: 0 +unretract_speed: 10 +[gcode_arcs] +resolution: 1.0 +[respond] +default_type: echo +default_prefix: echo: +[exclude_object] +[input_shaper] +shaper_freq_x: 0 +shaper_freq_y: 0 +shaper_type: mzv +shaper_type_x: +shaper_type_y: +damping_ratio_x: 0.1 +damping_ratio_y: 0.1 +[adxl345] +cs_pin: +spi_speed: 5000000 +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +axes_map: x, y, z +rate: 3200 +[lis2dw] +cs_pin: +spi_speed: 5000000 +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +axes_map: x, y, z +[mpu9250 my_accelerometer] +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: 400000 +axes_map: x, y, z +[resonance_tester] +probe_points: +accel_chip: +accel_chip_x: +accel_chip_y: +max_smoothing: +min_freq: 5 +max_freq: 133.33 +accel_per_hz: 75 +hz_per_sec: 1 +[board_pins my_aliases] +mcu: mcu +aliases: +aliases_: +[duplicate_pin_override] +pins: +[probe] +pin: +deactivate_on_each_sample: True +x_offset: 0.0 +y_offset: 0.0 +z_offset: +speed: 5.0 +samples: 1 +sampleretract_dist: 2.0 +lift_speed: +samples_result: average +samples_tolerance: 0.100 +samples_toleranceretries: 0 +activate_gcode: +deactivate_gcode: +[bltouch] +sensor_pin: +control_pin: +pin_move_time: 0.680 +stow_on_each_sample: True +probe_with_touch_mode: False +pin_up_reports_not_triggered: True +pin_up_touch_modereports_triggered: True +set_output_mode: +x_offset: +y_offset: +z_offset: +speed: +lift_speed: +samples: +sampleretract_dist: +samples_result: +samples_tolerance: +samples_toleranceretries: +[smart_effector] +pin: +control_pin: +probe_accel: +recovery_time: 0.4 +x_offset: +y_offset: +z_offset: +speed: +samples: +sampleretract_dist: +samples_result: +samples_tolerance: +samples_toleranceretries: +activate_gcode: +deactivate_gcode: +deactivate_on_each_sample: +[probe_eddy_current my_eddy_probe] +sensor_type: ldc1612 +intb_pin: +z_offset: +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +x_offset: +y_offset: +speed: +lift_speed: +samples: +sampleretract_dist: +samples_result: +samples_tolerance: +samples_toleranceretries: +[axis_twist_compensation] +speed: 50 +horizontal_move_z: 5 +calibrate_start_x: 20 +calibrate_end_x: 200 +calibrate_y: 112.5 +[stepper_z1] +step_pin: +dir_pin: +enable_pin: +microsteps: +rotation_distance: +endstop_pin: +[extruder1] +step_pin: +dir_pin: +shared_heater: +[dual_carriage] +axis: +safe_distance: +step_pin: +dir_pin: +enable_pin: +microsteps: +rotation_distance: +endstop_pin: +position_endstop: +position_min: +position_max: +[extruder_stepper my_extra_stepper] +extruder: +step_pin: +dir_pin: +enable_pin: +microsteps: +rotation_distance: +[manual_stepper my_stepper] +step_pin: +dir_pin: +enable_pin: +microsteps: +rotation_distance: +velocity: +accel: +endstop_pin: +[verify_heater heater_config_name] +max_error: 120 +check_gain_time: +hysteresis: 5 +heating_gain: 2 +[homing_heaters] +steppers: +heaters: +[thermistor my_thermistor] +temperature1: +resistance1: +temperature2: +resistance2: +temperature3: +resistance3: +beta: +[adc_temperature my_sensor] +temperature1: +voltage1: +temperature2: +voltage2: +temperature1: +resistance1: +temperature2: +resistance2: +[heater_generic my_generic_heater] +gcode_id: +heater_pin: +max_power: +sensor_type: +sensor_pin: +smooth_time: +control: +pid_Kp: +pid_Ki: +pid_Kd: +pwm_cycle_time: +min_temp: +max_temp: +[temperature_sensor my_sensor] +sensor_type: +sensor_pin: +min_temp: +max_temp: +gcode_id: +[temperature_probe my_probe] +sensor_type: +sensor_pin: +min_temp: +max_temp: +smooth_time: +gcode_id: +speed: +horizontal_move_z: +resting_z: +calibration_position: +calibration_bed_temp: +calibration_extruder_temp: +extruder_heating_z: 50. +max_validation_temp: 60. +sensor_type: +sensor_pin: +pullup_resistor: 4700 +inlineresistor: 0 +sensor_type: +sensor_pin: +adc_voltage: 5.0 +voltage_offset: 0 +sensor_type: PT1000 +sensor_pin: +pullup_resistor: 4700 +sensor_type: +sensor_pin: +spi_speed: 4000000 +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +tc_type: K +tc_use_50Hz_filter: False +tc_averaging_count: 1 +rtd_nominal_r: 100 +rtd_referencer: 430 +rtd_num_of_wires: 2 +rtd_use_50Hz_filter: False +sensor_type: BME280 +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +sensor_type: AHT10 +i2c_address: +i2c_mcu: +i2c_bus: +i2c_speed: +aht10_report_time: +sensor_type: +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +htu21d_hold_master: +htu21d_resolution: +htu21d_report_time: +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +lm75_report_time: +sensor_type: temperature_mcu +sensor_mcu: mcu +sensor_temperature1: +sensor_adc1: +sensor_temperature2: +sensor_adc2: +sensor_type: temperature_host +sensor_path: +sensor_type: DS18B20 +serial_no: +ds18_report_time: +sensor_mcu: +sensor_type: temperature_combined +sensor_list: +combination_method: +maximum_deviation: +[fan] +pin: +max_power: 1.0 +shutdown_speed: 0 +cycle_time: 0.010 +hardware_pwm: False +kick_start_time: 0.100 +off_below: 0.0 +tachometer_pin: +tachometer_ppr: 2 +tachometer_poll_interval: 0.0015 +enable_pin: +[heater_fan heatbreak_cooling_fan] +pin: +max_power: +shutdown_speed: +cycle_time: +hardware_pwm: +kick_start_time: +off_below: +tachometer_pin: +tachometer_ppr: +tachometer_poll_interval: +enable_pin: +heater: extruder +heater_temp: 50.0 +fan_speed: 1.0 +[controller_fan my_controller_fan] +pin: +max_power: +shutdown_speed: +cycle_time: +hardware_pwm: +kick_start_time: +off_below: +tachometer_pin: +tachometer_ppr: +tachometer_poll_interval: +enable_pin: +fan_speed: 1.0 +idle_timeout: +idle_speed: +heater: +stepper: +[temperature_fan my_temp_fan] +pin: +max_power: +shutdown_speed: +cycle_time: +hardware_pwm: +kick_start_time: +off_below: +tachometer_pin: +tachometer_ppr: +tachometer_poll_interval: +enable_pin: +sensor_type: +sensor_pin: +control: +max_delta: +min_temp: +max_temp: +pid_Kp: +pid_Ki: +pid_Kd: +pid_deriv_time: 2.0 +target_temp: 40.0 +max_speed: 1.0 +min_speed: 0.3 +gcode_id: +[fan_generic extruder_partfan] +pin: +max_power: +shutdown_speed: +cycle_time: +hardware_pwm: +kick_start_time: +off_below: +tachometer_pin: +tachometer_ppr: +tachometer_poll_interval: +enable_pin: +[led my_led] +red_pin: +green_pin: +blue_pin: +white_pin: +cycle_time: 0.010 +hardware_pwm: False +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +[neopixel my_neopixel] +pin: +chain_count: +color_order: GRB +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +[dotstar my_dotstar] +data_pin: +clock_pin: +chain_count: +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +[pca9533 my_pca9533] +i2c_address: 98 +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +[pca9632 my_pca9632] +i2c_address: 98 +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +scl_pin: +sda_pin: +color_order: RGBW +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +[servo my_servo] +pin: +maximum_servo_angle: 180 +minimum_pulse_width: 0.001 +maximum_pulse_width: 0.002 +initial_angle: +initial_pulse_width: +[gcode_button my_gcode_button] +pin: +analog_range: +analog_pullup_resistor: +press_gcode: +release_gcode: +[output_pin my_pin] +pin: +pwm: False +value: +shutdown_value: +cycle_time: 0.100 +hardware_pwm: False +scale: +maximum_mcu_duration: +static_value: +[pwm_tool my_tool] +pin: +maximum_mcu_duration: +value: +shutdown_value: +cycle_time: 0.100 +hardware_pwm: False +scale: +[pwm_cycle_time my_pin] +pin: +value: +shutdown_value: +cycle_time: 0.100 +scale: +[static_digital_output my_output_pins] +pins: +[multi_pin my_multi_pin] +pins: +[tmc2130 stepper_x] +cs_pin: +spi_speed: +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +chain_position: +chain_length: +interpolate: True +run_current: +hold_current: +senseresistor: 0.110 +stealthchop_threshold: 0 +coolstep_threshold: +high_velocity_threshold: +driver_MSLUT0: 2863314260 +driver_MSLUT1: 1251300522 +driver_MSLUT2: 608774441 +driver_MSLUT3: 269500962 +driver_MSLUT4: 4227858431 +driver_MSLUT5: 3048961917 +driver_MSLUT6: 1227445590 +driver_MSLUT7: 4211234 +driver_W0: 2 +driver_W1: 1 +driver_W2: 1 +driver_W3: 1 +driver_X1: 128 +driver_X2: 255 +driver_X3: 255 +driver_START_SIN: 0 +driver_START_SIN90: 247 +driver_IHOLDDELAY: 8 +driver_TPOWERDOWN: 0 +driver_TBL: 1 +driver_TOFF: 4 +driver_HEND: 7 +driver_HSTRT: 0 +driver_VHIGHFS: 0 +driver_VHIGHCHM: 0 +driver_PWM_AUTOSCALE: True +driver_PWM_FREQ: 1 +driver_PWM_GRAD: 4 +driver_PWM_AMPL: 128 +driver_SGT: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +driver_SFILT: 0 +diag0_pin: +diag1_pin: +[tmc2208 stepper_x] +uart_pin: +tx_pin: +select_pins: +interpolate: True +run_current: +hold_current: +sense_resistor: 0.110 +stealthchop_threshold: 0 +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 8 +driver_TPOWERDOWN: 20 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 0 +driver_HSTRT: 5 +driver_PWM_AUTOGRAD: True +driver_PWM_AUTOSCALE: True +driver_PWM_LIM: 12 +driver_PWM_REG: 8 +driver_PWM_FREQ: 1 +driver_PWM_GRAD: 14 +driver_PWM_OFS: 36 +[tmc2209 stepper_x] +uart_pin: +tx_pin: +select_pins: +interpolate: True +run_current: +hold_current: +sense_resistor: 0.110 +stealthchop_threshold: 0 +coolstep_threshold: +uart_address: +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 8 +driver_TPOWERDOWN: 20 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 0 +driver_HSTRT: 5 +driver_PWM_AUTOGRAD: True +driver_PWM_AUTOSCALE: True +driver_PWM_LIM: 12 +driver_PWM_REG: 8 +driver_PWM_FREQ: 1 +driver_PWM_GRAD: 14 +driver_PWM_OFS: 36 +driver_SGTHRS: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +diag_pin: +[tmc2660 stepper_x] +cs_pin: +spi_speed: 4000000 +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +interpolate: True +run_current: +sense_resistor: +idle_current_percent: 100 +driver_TBL: 2 +driver_RNDTF: 0 +driver_HDEC: 0 +driver_CHM: 0 +driver_HEND: 3 +driver_HSTRT: 3 +driver_TOFF: 4 +driver_SEIMIN: 0 +driver_SEDN: 0 +driver_SEMAX: 0 +driver_SEUP: 0 +driver_SEMIN: 0 +driver_SFILT: 0 +driver_SGT: 0 +driver_SLPH: 0 +driver_SLPL: 0 +driver_DISS2G: 0 +driver_TS2G: 3 +[tmc2240 stepper_x] +cs_pin: +spi_speed: +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +uart_pin: +chain_position: +chain_length: +interpolate: True +run_current: +hold_current: +rref: 12000 +stealthchop_threshold: 0 +coolstep_threshold: +high_velocity_threshold: +driver_MSLUT0: 2863314260 +driver_MSLUT1: 1251300522 +driver_MSLUT2: 608774441 +driver_MSLUT3: 269500962 +driver_MSLUT4: 4227858431 +driver_MSLUT5: 3048961917 +driver_MSLUT6: 1227445590 +driver_MSLUT7: 4211234 +driver_W0: 2 +driver_W1: 1 +driver_W2: 1 +driver_W3: 1 +driver_X1: 128 +driver_X2: 255 +driver_X3: 255 +driver_START_SIN: 0 +driver_START_SIN90: 247 +driver_OFFSET_SIN90: 0 +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 6 +driver_IRUNDELAY: 4 +driver_TPOWERDOWN: 10 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 2 +driver_HSTRT: 5 +driver_FD3: 0 +driver_TPFD: 4 +driver_CHM: 0 +driver_VHIGHFS: 0 +driver_VHIGHCHM: 0 +driver_DISS2G: 0 +driver_DISS2VS: 0 +driver_PWM_AUTOSCALE: True +driver_PWM_AUTOGRAD: True +driver_PWM_FREQ: 0 +driver_FREEWHEEL: 0 +driver_PWM_GRAD: 0 +driver_PWM_OFS: 29 +driver_PWM_REG: 4 +driver_PWM_LIM: 12 +driver_SGT: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +driver_SFILT: 0 +driver_SG4_ANGLE_OFFSET: 1 +diag0_pin: +diag1_pin: +[tmc5160 stepper_x] +cs_pin: +spi_speed: +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +chain_position: +chain_length: +interpolate: True +run_current: +hold_current: +sense_resistor: 0.075 +stealthchop_threshold: 0 +coolstep_threshold: +high_velocity_threshold: +driver_MSLUT0: 2863314260 +driver_MSLUT1: 1251300522 +driver_MSLUT2: 608774441 +driver_MSLUT3: 269500962 +driver_MSLUT4: 4227858431 +driver_MSLUT5: 3048961917 +driver_MSLUT6: 1227445590 +driver_MSLUT7: 4211234 +driver_W0: 2 +driver_W1: 1 +driver_W2: 1 +driver_W3: 1 +driver_X1: 128 +driver_X2: 255 +driver_X3: 255 +driver_START_SIN: 0 +driver_START_SIN90: 247 +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 6 +driver_TPOWERDOWN: 10 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 2 +driver_HSTRT: 5 +driver_FD3: 0 +driver_TPFD: 4 +driver_CHM: 0 +driver_VHIGHFS: 0 +driver_VHIGHCHM: 0 +driver_DISS2G: 0 +driver_DISS2VS: 0 +driver_PWM_AUTOSCALE: True +driver_PWM_AUTOGRAD: True +driver_PWM_FREQ: 0 +driver_FREEWHEEL: 0 +driver_PWM_GRAD: 0 +driver_PWM_OFS: 30 +driver_PWM_REG: 4 +driver_PWM_LIM: 12 +driver_SGT: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +driver_SFILT: 0 +driver_DRVSTRENGTH: 0 +driver_BBMCLKS: 4 +driver_BBMTIME: 0 +driver_FILT_ISENSE: 0 +diag0_pin: +diag1_pin: +[ad5206 my_digipot] +enable_pin: +spi_speed: +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +channel_1: +channel_2: +channel_3: +channel_4: +channel_5: +channel_6: +scale: +[mcp4451 my_digipot] +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +wiper_0: +wiper_1: +wiper_2: +wiper_3: +scale: +[mcp4728 my_dac] +i2c_address: 96 +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +channel_a: +channel_b: +channel_c: +channel_d: +scale: +[mcp4018 my_digipot] +scl_pin: +sda_pin: +wiper: +scale: +[display] +lcd_type: +display_group: +menu_timeout: +menu_root: +menu_reverse_navigation: +encoder_pins: +encoder_steps_per_detent: +click_pin: +back_pin: +up_pin: +down_pin: +kill_pin: +analog_pullup_resistor: 4700 +analog_range_click_pin: +analog_range_back_pin: +analog_range_up_pin: +analog_range_down_pin: +analog_range_kill_pin: +[display] +lcd_type: hd44780 +rs_pin: +e_pin: +d4_pin: +d5_pin: +d6_pin: +d7_pin: +hd44780_protocol_init: True +line_length: +[display] +lcd_type: hd44780_spi +latch_pin: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +hd44780_protocol_init: True +line_length: +[display] +lcd_type: st7920 +cs_pin: +sclk_pin: +sid_pin: +[display] +lcd_type: emulated_st7920 +en_pin: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +[display] +lcd_type: uc1701 +cs_pin: +a0_pin: +rst_pin: +contrast: +[display] +lcd_type: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +cs_pin: +dc_pin: +spi_speed: +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +reset_pin: +contrast: +vcomh: 0 +invert: False +x_offset: 0 +[display_data my_group_name my_data_name] +position: +text: +[display_template my_template_name] +param_: +text: +[display_glyph my_display_glyph] +data: +hd44780_data: +hd44780_slot: +[menu __some_list __some_name] +type: disabled +[menu some_name] +type: +name: +enable: +index: +[menu some_list] +type: list +name: +enable: +[menu some_list some_command] +type: command +name: +enable: +gcode: +[menu some_list some_input] +type: input +name: +enable: +input: +input_min: +input_max: +input_step: +realtime: +gcode: +[filament_switch_sensor my_sensor] +pause_on_runout: True +runout_gcode: +insert_gcode: +event_delay: 3.0 +pause_delay: 0.5 +switch_pin: +[filament_motion_sensor my_sensor] +detection_length: 7.0 +extruder: +switch_pin: +pause_on_runout: +runout_gcode: +insert_gcode: +event_delay: +pause_delay: +[tsl1401cl_filament_width_sensor] +pin: +default_nominal_filament_diameter: 1.75 +max_difference: 0.2 +measurement_delay: 100 +[hall_filament_width_sensor] +adc1: +adc2: +cal_dia1: 1.50 +cal_dia2: 2.00 +raw_dia1: 9500 +raw_dia2: 10500 +default_nominal_filament_diameter: 1.75 +max_difference: 0.200 +measurement_delay: 70 +enable: False +measurement_interval: 10 +logging: False +min_diameter: 1.0 +max_diameter: +use_current_dia_while_delay: False +pause_on_runout: +runout_gcode: +insert_gcode: +event_delay: +pause_delay: +[load_cell] +sensor_type: +[load_cell] +sensor_type: hx711 +sclk_pin: +dout_pin: +gain: A-128 +sample_rate: 80 +[load_cell] +sensor_type: hx717 +sclk_pin: +dout_pin: +gain: A-128 +sample_rate: 320 +[load_cell] +sensor_type: ads1220 +cs_pin: +spi_speed: 512000 +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +data_ready_pin: +gain: 128 +sample_rate: 660 +[sx1509 my_sx1509] +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: +[samd_sercom my_sercom] +sercom: +tx_pin: +rx_pin: +clk_pin: +[adc_scaled my_name] +vref_pin: +vssa_pin: +smooth_time: 2.0 +[replicape] +revision: +enable_pin: !gpio0_20 +host_mcu: +standstill_power_down: False +stepper_x_microstep_mode: +stepper_y_microstep_mode: +stepper_z_microstep_mode: +stepper_e_microstep_mode: +stepper_h_microstep_mode: +stepper_x_current: +stepper_y_current: +stepper_z_current: +stepper_e_current: +stepper_h_current: +stepper_x_chopper_off_time_high: +stepper_y_chopper_off_time_high: +stepper_z_chopper_off_time_high: +stepper_e_chopper_off_time_high: +stepper_h_chopper_off_time_high: +stepper_x_chopper_hysteresis_high: +stepper_y_chopper_hysteresis_high: +stepper_z_chopper_hysteresis_high: +stepper_e_chopper_hysteresis_high: +stepper_h_chopper_hysteresis_high: +stepper_x_chopper_blank_time_high: +stepper_y_chopper_blank_time_high: +stepper_z_chopper_blank_time_high: +stepper_e_chopper_blank_time_high: +stepper_h_chopper_blank_time_high: +[palette2] +serial: +baud: 115200 +feedrate_splice: 0.8 +feedrate_normal: 1.0 +auto_load_speed: 2 +auto_cancel_variation: 0.1 +[angle my_angle_sensor] +sensor_type: +sample_period: 0.000400 +stepper: +cs_pin: +spi_speed: +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +spi_speed: +spi_bus: +spi_software_sclk_pin: +spi_software_mosi_pin: +spi_software_miso_pin: +i2c_address: +i2c_mcu: +i2c_bus: +i2c_software_scl_pin: +i2c_software_sda_pin: +i2c_speed: diff --git a/kiauh/core/submodules/simple_config_parser/tests/assets/test_config_1.cfg b/kiauh/core/submodules/simple_config_parser/tests/assets/test_config_1.cfg new file mode 100644 index 0000000..fae1917 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/assets/test_config_1.cfg @@ -0,0 +1,32 @@ +# a comment at the very top +# should be treated as the file header + +# up to the first section, including all blank lines + +[section_1] +option_1: value_1 +option_1_1: True # this is a boolean +option_1_2: 5 ; this is an integer +option_1_3: 1.123 #;this is a float + +[section_2] ; comment +option_2: value_2 + +; comment + +[section_3] +option_3: value_3 # comment + +[section_4] +# comment +option_4: value_4 + +[section number 5] +#option_5: value_5 +option_5 = this.is.value-5 +multi_option: + # these are multi-line values + value_5_1 + value_5_2 ; here is a comment + value_5_3 +option_5_1: value_5_1 diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/internal_state/test_content_handling.py b/kiauh/core/submodules/simple_config_parser/tests/features/internal_state/test_content_handling.py deleted file mode 100644 index d54681e..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/internal_state/test_content_handling.py +++ /dev/null @@ -1,95 +0,0 @@ -import pytest - -from src.simple_config_parser.simple_config_parser import SimpleConfigParser - - -@pytest.fixture -def parser(): - parser = SimpleConfigParser() - parser._header = ["header1\n", "header2\n"] - parser._config = { - "section1": { - "_raw": "[section1]\n", - "body": [ - { - "_raw": "option1: value1\n", - "_raw_value": "value1\n", - "is_multiline": False, - "option": "option1", - "value": "value1", - }, - { - "_raw": "option2: value2\n", - "_raw_value": "value2\n", - "is_multiline": False, - "option": "option2", - "value": "value2", - }, - ], - }, - "section2": { - "_raw": "[section2]\n", - "body": [ - { - "_raw": "option3: value3\n", - "_raw_value": "value3\n", - "is_multiline": False, - "option": "option3", - "value": "value3", - }, - ], - }, - "section3": { - "_raw": "[section3]\n", - "body": [ - { - "_raw": "option4:\n", - "_raw_value": [" value4\n", " value5\n", " value6\n"], - "is_multiline": True, - "option": "option4", - "value": ["value4", "value5", "value6"], - }, - ], - }, - } - return parser - - -def test_construct_content(parser): - content = parser._construct_content() - assert ( - content == "header1\nheader2\n" - "[section1]\n" - "option1: value1\n" - "option2: value2\n" - "[section2]\n" - "option3: value3\n" - "[section3]\n" - "option4:\n" - " value4\n" - " value5\n" - " value6\n" - ) - - -def test_construct_content_no_header(parser): - parser._header = None - content = parser._construct_content() - assert ( - content == "[section1]\n" - "option1: value1\n" - "option2: value2\n" - "[section2]\n" - "option3: value3\n" - "[section3]\n" - "option4:\n" - " value4\n" - " value5\n" - " value6\n" - ) - - -def test_construct_content_no_sections(parser): - parser._config = {} - content = parser._construct_content() - assert content == "".join(parser._header) diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/internal_state/test_internal_state_changes.py b/kiauh/core/submodules/simple_config_parser/tests/features/internal_state/test_internal_state_changes.py deleted file mode 100644 index 789368c..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/internal_state/test_internal_state_changes.py +++ /dev/null @@ -1,84 +0,0 @@ -import pytest - -from src.simple_config_parser.simple_config_parser import ( - DuplicateOptionError, - DuplicateSectionError, - SimpleConfigParser, -) - - -@pytest.fixture -def parser(): - return SimpleConfigParser() - - -class TestInternalStateChanges: - @pytest.mark.parametrize( - "given", ["dummy_section", "dummy_section 2", "another_section"] - ) - def test_ensure_section_body_exists(self, parser, given): - parser._config = {} - parser.section_name = given - parser._ensure_section_body_exists() - - assert parser._config[given] is not None - assert parser._config[given]["body"] == [] - - def test_add_option_to_section_body(self): - pass - - @pytest.mark.parametrize( - "given", ["dummy_section", "dummy_section 2", "another_section\n"] - ) - def test_store_internal_state_section(self, parser, given): - parser._store_internal_state_section(given, given) - - assert parser._all_sections == [given] - assert parser._all_options[given] == {} - assert parser._config[given]["body"] == [] - assert parser._config[given]["_raw"] == given - - def test_duplicate_section_error(self, parser): - section_name = "dummy_section" - parser._all_sections = [section_name] - - with pytest.raises(DuplicateSectionError) as excinfo: - parser._store_internal_state_section(section_name, section_name) - message = f"Section '{section_name}' is defined more than once" - assert message in str(excinfo.value) - - # Check that the internal state of the parser is correct - assert parser.in_option_block is False - assert parser.section_name == "" - assert parser._all_sections == [section_name] - - @pytest.mark.parametrize( - "given_name, given_value, given_raw_value", - [("dummyoption", "dummyvalue", "dummyvalue\n")], - ) - def test_store_internal_state_option( - self, parser, given_name, given_value, given_raw_value - ): - parser.section_name = "dummy_section" - parser._store_internal_state_option(given_name, given_value, given_raw_value) - - assert parser._all_options[parser.section_name] == {given_name: given_value} - - new_option = { - "is_multiline": False, - "option": given_name, - "value": given_value, - "_raw": given_raw_value, - } - assert parser._config[parser.section_name]["body"] == [new_option] - - def test_duplicate_option_error(self, parser): - option_name = "dummyoption" - value = "dummyvalue" - parser.section_name = "dummy_section" - parser._all_options = {parser.section_name: {option_name: value}} - - with pytest.raises(DuplicateOptionError) as excinfo: - parser._store_internal_state_option(option_name, value, value) - message = f"Option '{option_name}' in section '{parser.section_name}' is defined more than once" - assert message in str(excinfo.value) diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_comment.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_comment.py deleted file mode 100644 index d84b40f..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_comment.py +++ /dev/null @@ -1,6 +0,0 @@ -testcases = [ - "# comment # 1", - "; comment # 2", - " ; indented comment", - " # another indented comment", -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_option.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_option.py deleted file mode 100644 index df849be..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_option.py +++ /dev/null @@ -1,28 +0,0 @@ -testcases = [ - ("option: value", "option", "value"), - ("option : value", "option", "value"), - ("option :value", "option", "value"), - ("option= value", "option", "value"), - ("option = value", "option", "value"), - ("option =value", "option", "value"), - ("option: value\n", "option", "value"), - ("option: value # inline comment", "option", "value"), - ("option: value # inline comment\n", "option", "value"), - ( - "description: Helper: park toolhead used in PAUSE and CANCEL_PRINT", - "description", - "Helper: park toolhead used in PAUSE and CANCEL_PRINT", - ), - ("description: homing!", "description", "homing!"), - ("description: inline macro :-)", "description", "inline macro :-)"), - ("path: %GCODES_DIR%", "path", "%GCODES_DIR%"), - ( - "serial = /dev/serial/by-id/", - "serial", - "/dev/serial/by-id/", - ), - ("parameter_temperature_(°C): 155", "parameter_temperature_(°C)", "155"), - ("parameter_humidity_(%_RH): 45", "parameter_humidity_(%_RH)", "45"), - ("parameter_spool_weight_(%): 10", "parameter_spool_weight_(%)", "10"), - ("path: /dev/shm/drying_box.json", "path", "/dev/shm/drying_box.json"), -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_section.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_section.py deleted file mode 100644 index bab0f69..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/data/case_parse_section.py +++ /dev/null @@ -1,8 +0,0 @@ -testcases = [ - ("[test_section]", "test_section"), - ("[test_section two]", "test_section two"), - ("[section1] # inline comment", "section1"), - ("[section2] ; second comment", "section2"), - ("[include moonraker-obico-update.cfg]", "include moonraker-obico-update.cfg"), - ("[include moonraker_obico_macros.cfg]", "include moonraker_obico_macros.cfg"), -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/test_single_line_parsing.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/test_single_line_parsing.py deleted file mode 100644 index fd2e4a1..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_parsing/test_single_line_parsing.py +++ /dev/null @@ -1,92 +0,0 @@ -import pytest -from data.case_parse_comment import testcases as case_parse_comment -from data.case_parse_option import testcases as case_parse_option -from data.case_parse_section import testcases as case_parse_section - -from src.simple_config_parser.simple_config_parser import ( - Option, - SimpleConfigParser, -) - - -@pytest.fixture -def parser(): - return SimpleConfigParser() - - -class TestSingleLineParsing: - @pytest.mark.parametrize("given, expected", [*case_parse_section]) - def test_parse_section(self, parser, given, expected): - parser._parse_section(given) - - # Check that the internal state of the parser is correct - assert parser.section_name == expected - assert parser.in_option_block is False - assert parser._all_sections == [expected] - assert parser._config[expected]["_raw"] == given - assert parser._config[expected]["body"] == [] - - @pytest.mark.parametrize( - "given, expected_option, expected_value", [*case_parse_option] - ) - def test_parse_option(self, parser, given, expected_option, expected_value): - section_name = "test_section" - parser.section_name = section_name - parser._parse_option(given) - - # Check that the internal state of the parser is correct - assert parser.section_name == section_name - assert parser.in_option_block is False - assert parser._all_options[section_name][expected_option] == expected_value - - section_option = parser._config[section_name]["body"][0] - assert section_option["option"] == expected_option - assert section_option["value"] == expected_value - assert section_option["_raw"] == given - - @pytest.mark.parametrize( - "option, next_line", - [("gcode", "next line"), ("gcode", " {{% some jinja template %}}")], - ) - def test_parse_multiline_option(self, parser, option, next_line): - parser.section_name = "dummy_section" - parser.in_option_block = True - parser._add_option_to_section_body(option, "", option) - parser._parse_multiline_option(option, next_line) - cleaned_next_line = next_line.strip().strip("\n") - - assert parser._all_options[parser.section_name] is not None - assert parser._all_options[parser.section_name][option] == [cleaned_next_line] - - expected_option: Option = { - "is_multiline": True, - "option": option, - "value": [cleaned_next_line], - "_raw": option, - "_raw_value": [next_line], - } - assert parser._config[parser.section_name]["body"] == [expected_option] - - @pytest.mark.parametrize("given", [*case_parse_comment]) - def test_parse_comment(self, parser, given): - parser.section_name = "dummy_section" - parser._parse_comment(given) - - # internal state checks after parsing - assert parser.in_option_block is False - - expected_option = { - "is_multiline": False, - "_raw": given, - "option": "", - "value": "", - } - assert parser._config[parser.section_name]["body"] == [expected_option] - - @pytest.mark.parametrize("given", ["# header line", "; another header line"]) - def test_parse_header_comment(self, parser, given): - parser.section_name = "" - parser._parse_comment(given) - - assert parser.in_option_block is False - assert parser._header == [given] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_comment.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_comment.py deleted file mode 100644 index 107745c..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_comment.py +++ /dev/null @@ -1,9 +0,0 @@ -testcases = [ - ("# an arbitrary comment", True), - ("; another arbitrary comment", True), - (" ; indented comment", True), - (" # indented comment", True), - ("not_a: comment", False), - ("also_not_a= comment", False), - ("[definitely_not_a_comment]", False), -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_empty.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_empty.py deleted file mode 100644 index 7fe6afc..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_empty.py +++ /dev/null @@ -1,9 +0,0 @@ -testcases = [ - ("", True), - (" ", True), - ("not empty", False), - (" # indented comment", False), - ("not: empty", False), - ("also_not= empty", False), - ("[definitely_not_empty]", False), -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_multiline_option.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_multiline_option.py deleted file mode 100644 index ddf74d5..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_multiline_option.py +++ /dev/null @@ -1,27 +0,0 @@ -testcases = [ - ("valid_option:", True), - ("valid_option:\n", True), - ("valid_option: ; inline comment", True), - ("valid_option: # inline comment", True), - ("valid_option :", True), - ("valid_option=", True), - ("valid_option= ", True), - ("valid_option =", True), - ("valid_option = ", True), - ("invalid_option ==", False), - ("invalid_option :=", False), - ("not_a_valid_option", False), - ("", False), - ("# that's a comment", False), - ("; that's a comment", False), - ("parameter_humidity_(%_RH):", True), - ("parameter_spool_weight_(%):", True), - ("parameter_temperature_(°C):", True), - ("parameter_humidity_(%_RH): 18.123", False), - ("parameter_spool_weight_(%): 150", False), - ("parameter_temperature_(°C): 30,5", False), - ("trusted_clients:", True), - ("trusted_clients: 192.168.1.0/24", False), - ("cors_domains:", True), - ("cors_domains: http://*.lan", False), -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_option.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_option.py deleted file mode 100644 index b33e6a8..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_option.py +++ /dev/null @@ -1,31 +0,0 @@ -testcases = [ - ("valid_option: value", True), - ("valid_option: value\n", True), - ("valid_option: value ; inline comment", True), - ("valid_option: value # inline comment", True), - ("valid_option: value # inline comment\n", True), - ("valid_option : value", True), - ("valid_option :value", True), - ("valid_option= value", True), - ("valid_option = value", True), - ("valid_option =value", True), - ("invalid_option:", False), - ("invalid_option=", False), - ("invalid_option:: value", False), - ("invalid_option :: value", False), - ("invalid_option ::value", False), - ("invalid_option== value", False), - ("invalid_option == value", False), - ("invalid_option ==value", False), - ("invalid_option:= value", False), - ("invalid_option := value", False), - ("invalid_option :=value", False), - ("[that_is_a_section]", False), - ("[that_is_section two]", False), - ("not_a_valid_option", False), - ("description: homing!", True), - ("description: inline macro :-)", True), - ("path: %GCODES_DIR%", True), - ("path: /dev/shm/drying_box.json", True), - ("serial = /dev/serial/by-id/", True), -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_section.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_section.py deleted file mode 100644 index 42b93d0..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/data/case_line_is_section.py +++ /dev/null @@ -1,12 +0,0 @@ -testcases = [ - ("[example_section]", True), - ("[gcode_macro CANCEL_PRINT]", True), - ("[gcode_macro SET_PAUSE_NEXT_LAYER]", True), - ("[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL]", True), - ("[update_manager moonraker-obico]", True), - ("[include moonraker_obico_macros.cfg]", True), - ("[include moonraker-obico-update.cfg]", True), - ("[example_section two]", True), - ("not_a_valid_section", False), - ("section: invalid", False), -] diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/test_line_type_detection.py b/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/test_line_type_detection.py deleted file mode 100644 index 854fde7..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/line_type_detection/test_line_type_detection.py +++ /dev/null @@ -1,37 +0,0 @@ -import pytest -from data.case_line_is_comment import testcases as case_line_is_comment -from data.case_line_is_empty import testcases as case_line_is_empty -from data.case_line_is_multiline_option import ( - testcases as case_line_is_multiline_option, -) -from data.case_line_is_option import testcases as case_line_is_option -from data.case_line_is_section import testcases as case_line_is_section - -from src.simple_config_parser.simple_config_parser import SimpleConfigParser - - -@pytest.fixture -def parser(): - return SimpleConfigParser() - - -class TestLineTypeDetection: - @pytest.mark.parametrize("given, expected", [*case_line_is_section]) - def test_line_is_section(self, parser, given, expected): - assert parser._is_section(given) is expected - - @pytest.mark.parametrize("given, expected", [*case_line_is_option]) - def test_line_is_option(self, parser, given, expected): - assert parser._is_option(given) is expected - - @pytest.mark.parametrize("given, expected", [*case_line_is_multiline_option]) - def test_line_is_multiline_option(self, parser, given, expected): - assert parser._is_multiline_option(given) is expected - - @pytest.mark.parametrize("given, expected", [*case_line_is_comment]) - def test_line_is_comment(self, parser, given, expected): - assert parser._is_comment(given) is expected - - @pytest.mark.parametrize("given, expected", [*case_line_is_empty]) - def test_line_is_empty(self, parser, given, expected): - assert parser._is_empty_line(given) is expected diff --git a/kiauh/core/submodules/simple_config_parser/tests/features/public_api/test_public_api.py b/kiauh/core/submodules/simple_config_parser/tests/features/public_api/test_public_api.py deleted file mode 100644 index 0e59b5a..0000000 --- a/kiauh/core/submodules/simple_config_parser/tests/features/public_api/test_public_api.py +++ /dev/null @@ -1,196 +0,0 @@ -import pytest - -from src.simple_config_parser.simple_config_parser import ( - DuplicateSectionError, - NoOptionError, - NoSectionError, - SimpleConfigParser, -) - - -@pytest.fixture -def parser(): - return SimpleConfigParser() - - -class TestPublicAPI: - def test_has_section(self, parser): - parser._all_sections = ["section1"] - assert parser.has_section("section1") is True - - @pytest.mark.parametrize("section", ["section1", "section2", "section three"]) - def test_add_section(self, parser, section): - parser.add_section(section) - - assert section in parser._all_sections - assert parser._all_options[section] == {} - - cfg_section = {"_raw": f"\n[{section}]\n", "body": []} - assert parser._config[section] == cfg_section - - @pytest.mark.parametrize("section", ["section1", "section2", "section three"]) - def test_add_existing_section(self, parser, section): - parser._all_sections = [section] - - with pytest.raises(DuplicateSectionError): - parser.add_section(section) - - assert parser._all_sections == [section] - - @pytest.mark.parametrize("section", ["section1", "section2", "section three"]) - def test_remove_section(self, parser, section): - parser.add_section(section) - parser.remove_section(section) - - assert section not in parser._all_sections - assert section not in parser._all_options - assert section not in parser._config - - @pytest.mark.parametrize("section", ["section1", "section2", "section three"]) - def test_remove_non_existing_section(self, parser, section): - with pytest.raises(NoSectionError): - parser.remove_section(section) - - def test_get_all_sections(self, parser): - parser.add_section("section1") - parser.add_section("section2") - parser.add_section("section three") - - assert parser.sections() == ["section1", "section2", "section three"] - - def test_has_option(self, parser): - parser.add_section("section1") - parser.set("section1", "option1", "value1") - - assert parser.has_option("section1", "option1") is True - - @pytest.mark.parametrize( - "section, option, value", - [ - ("section1", "option1", "value1"), - ("section2", "option2", "value2"), - ("section three", "option3", "value three"), - ], - ) - def test_set_new_option(self, parser, section, option, value): - parser.add_section(section) - parser.set(section, option, value) - - assert section in parser._all_sections - assert option in parser._all_options[section] - assert parser._all_options[section][option] == value - - assert parser._config[section]["body"][0]["is_multiline"] is False - assert parser._config[section]["body"][0]["option"] == option - assert parser._config[section]["body"][0]["value"] == value - assert parser._config[section]["body"][0]["_raw"] == f"{option}: {value}\n" - - def test_set_existing_option(self, parser): - section, option, value1, value2 = "section1", "option1", "value1", "value2" - - parser.add_section(section) - parser.set(section, option, value1) - parser.set(section, option, value2) - - assert parser._all_options[section][option] == value2 - assert parser._config[section]["body"][0]["is_multiline"] is False - assert parser._config[section]["body"][0]["option"] == option - assert parser._config[section]["body"][0]["value"] == value2 - assert parser._config[section]["body"][0]["_raw"] == f"{option}: {value2}\n" - - def test_set_new_multiline_option(self, parser): - section, option, value = "section1", "option1", "value1\nvalue2\nvalue3" - - parser.add_section(section) - parser.set(section, option, value) - - assert parser._config[section]["body"][0]["is_multiline"] is True - assert parser._config[section]["body"][0]["option"] == option - - values = ["value1", "value2", "value3"] - raw_values = [" value1\n", " value2\n", " value3\n"] - assert parser._config[section]["body"][0]["value"] == values - assert parser._config[section]["body"][0]["_raw"] == f"{option}:\n" - assert parser._config[section]["body"][0]["_raw_value"] == raw_values - assert parser._all_options[section][option] == values - - def test_set_option_of_non_existing_section(self, parser): - with pytest.raises(NoSectionError): - parser.set("section1", "option1", "value1") - - def test_remove_option(self, parser): - section, option, value = "section1", "option1", "value1" - - parser.add_section(section) - parser.set(section, option, value) - parser.remove_option(section, option) - - assert option not in parser._all_options[section] - assert option not in parser._config[section]["body"] - - def test_remove_non_existing_option(self, parser): - parser.add_section("section1") - with pytest.raises(NoOptionError): - parser.remove_option("section1", "option1") - - def test_remove_option_of_non_existing_section(self, parser): - with pytest.raises(NoSectionError): - parser.remove_option("section1", "option1") - - def test_get_option(self, parser): - parser.add_section("section1") - parser.add_section("section2") - parser.set("section1", "option1", "value1") - parser.set("section2", "option2", "value2") - parser.set("section2", "option3", "value two") - - assert parser.get("section1", "option1") == "value1" - assert parser.get("section2", "option2") == "value2" - assert parser.get("section2", "option3") == "value two" - - def test_get_option_of_non_existing_section(self, parser): - with pytest.raises(NoSectionError): - parser.get("section1", "option1") - - def test_get_option_of_non_existing_option(self, parser): - parser.add_section("section1") - with pytest.raises(NoOptionError): - parser.get("section1", "option1") - - def test_get_option_fallback(self, parser): - parser.add_section("section1") - assert parser.get("section1", "option1", "fallback_value") == "fallback_value" - - def test_get_options(self, parser): - parser.add_section("section1") - parser.set("section1", "option1", "value1") - parser.set("section1", "option2", "value2") - parser.set("section1", "option3", "value3") - - options = {"option1": "value1", "option2": "value2", "option3": "value3"} - assert parser.options("section1") == options - - def test_get_option_as_int(self, parser): - parser.add_section("section1") - parser.set("section1", "option1", "1") - - option = parser.getint("section1", "option1") - assert isinstance(option, int) is True - - def test_get_option_as_float(self, parser): - parser.add_section("section1") - parser.set("section1", "option1", "1.234") - - option = parser.getfloat("section1", "option1") - assert isinstance(option, float) is True - - @pytest.mark.parametrize( - "value", - ["True", "true", "on", "1", "yes", "False", "false", "off", "0", "no"], - ) - def test_get_option_as_boolean(self, parser, value): - parser.add_section("section1") - parser.set("section1", "option1", value) - - option = parser.getboolean("section1", "option1") - assert isinstance(option, bool) is True diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_data/matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_data/matching_data.txt new file mode 100644 index 0000000..6fb66a5 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_data/matching_data.txt @@ -0,0 +1,6 @@ + + + + + + diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_data/non_matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_data/non_matching_data.txt new file mode 100644 index 0000000..ceadadf --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_data/non_matching_data.txt @@ -0,0 +1,7 @@ +not_empty +[also_not_empty] +# +; + ; + # +option: value diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_match_empty_line.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_match_empty_line.py new file mode 100644 index 0000000..ff5f3ba --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_empty_line/test_match_empty_line.py @@ -0,0 +1,39 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # + +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import SimpleConfigParser +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.joinpath("test_data") +MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("matching_data.txt") +NON_MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("non_matching_data.txt") + + +@pytest.fixture +def parser(): + return SimpleConfigParser() + + +@pytest.mark.parametrize("line", load_testdata_from_file(MATCHING_TEST_DATA_PATH)) +def test_match_line_comment(parser, line): + """Test that a line matches the definition of a line comment""" + assert ( + parser._match_empty_line(line) is True + ), f"Expected line '{line}' to match line comment definition!" + + +@pytest.mark.parametrize("line", load_testdata_from_file(NON_MATCHING_TEST_DATA_PATH)) +def test_non_matching_line_comment(parser, line): + """Test that a line does not match the definition of a line comment""" + assert ( + parser._match_empty_line(line) is False + ), f"Expected line '{line}' to not match line comment definition!" diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_data/matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_data/matching_data.txt new file mode 100644 index 0000000..e9c232d --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_data/matching_data.txt @@ -0,0 +1,28 @@ +;[example_section] +#[example_section] +# [example_section] +; [example_section] +;[gcode_macro CANCEL_PRINT] +#[gcode_macro CANCEL_PRINT] +# [gcode_macro CANCEL_PRINT] +; [gcode_macro CANCEL_PRINT] +;[gcode_macro SET_PAUSE_NEXT_LAYER] +#[gcode_macro SET_PAUSE_NEXT_LAYER] +# [gcode_macro SET_PAUSE_NEXT_LAYER] +; [gcode_macro SET_PAUSE_NEXT_LAYER] +;[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] +#[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] +# [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] +; [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + ;[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + #[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + # [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + ; [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + ;[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + #[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + # [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + ; [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + ;[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + #[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + # [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] + ; [gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_data/non_matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_data/non_matching_data.txt new file mode 100644 index 0000000..0a585e8 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_data/non_matching_data.txt @@ -0,0 +1,5 @@ +not_a_comment: nono + +[also not a comment] +not_a_comment: ; comment +not_a_comment: # comment diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_match_line_comment.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_match_line_comment.py new file mode 100644 index 0000000..2e1f9df --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_line_comment/test_match_line_comment.py @@ -0,0 +1,39 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # + +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import SimpleConfigParser +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.joinpath("test_data") +MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("matching_data.txt") +NON_MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("non_matching_data.txt") + + +@pytest.fixture +def parser(): + return SimpleConfigParser() + + +@pytest.mark.parametrize("line", load_testdata_from_file(MATCHING_TEST_DATA_PATH)) +def test_match_line_comment(parser, line): + """Test that a line matches the definition of a line comment""" + assert ( + parser._match_line_comment(line) is True + ), f"Expected line '{line}' to match line comment definition!" + + +@pytest.mark.parametrize("line", load_testdata_from_file(NON_MATCHING_TEST_DATA_PATH)) +def test_non_matching_line_comment(parser, line): + """Test that a line does not match the definition of a line comment""" + assert ( + parser._match_line_comment(line) is False + ), f"Expected line '{line}' to not match line comment definition!" diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_data/matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_data/matching_data.txt new file mode 100644 index 0000000..ef6286d --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_data/matching_data.txt @@ -0,0 +1,461 @@ +baud: 250000 +minimum_cruise_ratio: 0.5 +square_corner_velocity: 5.0 +full_steps_per_rotation: 200 +position_min: 0 +homing_speed: 5.0 +homing_retract_dist: 5.0 +kinematics: cartesian +kinematics: delta +minimum_z_position: 0 +speed: 50 +horizontal_move_z: 5 +kinematics: deltesian +minimum_z_position: 0 +min_angle: 5 +slow_ratio: 3 +kinematics: corexy +kinematics: corexz +kinematics: hybrid_corexy +kinematics: hybrid_corexz +kinematics: polar +kinematics: rotary_delta +minimum_z_position: 0 +speed: 50 +horizontal_move_z: 5 +kinematics: winch +kinematics: none +max_velocity: 1 +max_accel: 1 +instantaneous_corner_velocity: 1.000 +max_extrude_only_distance: 50.0 +pressure_advance: 0.0 +pressure_advance_smooth_time: 0.040 +max_power: 1.0 +pullup_resistor: 4700 +smooth_time: 1.0 +max_delta: 2.0 +pwm_cycle_time: 0.100 +min_extrude_temp: 170 +speed: 50 +horizontal_move_z: 5 +probe_count: 3, 3 +round_probe_count: 5 +fade_start: 1.0 +fade_end: 0.0 +split_delta_z: .025 +move_check_distance: 5.0 +mesh_pps: 2, 2 +algorithm: lagrange +bicubic_tension: .2 +x_adjust: 0 +y_adjust: 0 +z_adjust: 0 +speed: 50 +horizontal_move_z: 5 +horizontal_move_z: 5 +probe_height: 0 +speed: 50 +probe_speed: 5 +speed: 50 +horizontal_move_z: 5 +screw_thread: CW-M3 +speed: 50 +horizontal_move_z: 5 +retries: 0 +retry_tolerance: 0 +speed: 50 +horizontal_move_z: 5 +max_adjust: 4 +retries: 0 +retry_tolerance: 0 +speed: 50.0 +z_hop_speed: 15.0 +move_to_previous: False +axes: xyz +endstop_align_zero: False +description: G-Code macro +initial_duration: 0.0 +timeout: 600 +enable_force_move: False +recover_velocity: 50. +retract_length: 0 +retract_speed: 20 +unretract_extra_length: 0 +unretract_speed: 10 +resolution: 1.0 +default_type: echo +default_prefix: echo: +shaper_freq_x: 0 +shaper_freq_y: 0 +shaper_type: mzv +damping_ratio_x: 0.1 +damping_ratio_y: 0.1 +spi_speed: 5000000 +axes_map: x, y, z +rate: 3200 +spi_speed: 5000000 +axes_map: x, y, z +i2c_speed: 400000 +axes_map: x, y, z +min_freq: 5 +max_freq: 133.33 +accel_per_hz: 75 +hz_per_sec: 1 +mcu: mcu +deactivate_on_each_sample: True +x_offset: 0.0 +y_offset: 0.0 +speed: 5.0 +samples: 1 +sampleretract_dist: 2.0 +samples_result: average +samples_tolerance: 0.100 +samples_toleranceretries: 0 +pin_move_time: 0.680 +stow_on_each_sample: True +probe_with_touch_mode: False +pin_up_reports_not_triggered: True +pin_up_touch_modereports_triggered: True +recovery_time: 0.4 +sensor_type: ldc1612 +speed: 50 +horizontal_move_z: 5 +calibrate_start_x: 20 +calibrate_end_x: 200 +calibrate_y: 112.5 +max_error: 120 +hysteresis: 5 +heating_gain: 2 +extruder_heating_z: 50. +max_validation_temp: 60. +pullup_resistor: 4700 +inlineresistor: 0 +adc_voltage: 5.0 +voltage_offset: 0 +sensor_type: PT1000 +pullup_resistor: 4700 +spi_speed: 4000000 +tc_type: K +tc_use_50Hz_filter: False +tc_averaging_count: 1 +rtd_nominal_r: 100 +rtd_referencer: 430 +rtd_num_of_wires: 2 +rtd_use_50Hz_filter: False +sensor_type: BME280 +sensor_type: AHT10 +sensor_type: temperature_mcu +sensor_mcu: mcu +sensor_type: temperature_host +sensor_type: DS18B20 +sensor_type: temperature_combined +max_power: 1.0 +shutdown_speed: 0 +cycle_time: 0.010 +hardware_pwm: False +kick_start_time: 0.100 +off_below: 0.0 +tachometer_ppr: 2 +tachometer_poll_interval: 0.0015 +heater: extruder +heater_temp: 50.0 +fan_speed: 1.0 +fan_speed: 1.0 +pid_deriv_time: 2.0 +target_temp: 40.0 +max_speed: 1.0 +min_speed: 0.3 +cycle_time: 0.010 +hardware_pwm: False +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +color_order: GRB +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +i2c_address: 98 +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +i2c_address: 98 +color_order: RGBW +initial_RED: 0.0 +initial_GREEN: 0.0 +initial_BLUE: 0.0 +initial_WHITE: 0.0 +maximum_servo_angle: 180 +minimum_pulse_width: 0.001 +maximum_pulse_width: 0.002 +pwm: False +cycle_time: 0.100 +hardware_pwm: False +cycle_time: 0.100 +hardware_pwm: False +cycle_time: 0.100 +interpolate: True +senseresistor: 0.110 +stealthchop_threshold: 0 +driver_MSLUT0: 2863314260 +driver_MSLUT1: 1251300522 +driver_MSLUT2: 608774441 +driver_MSLUT3: 269500962 +driver_MSLUT4: 4227858431 +driver_MSLUT5: 3048961917 +driver_MSLUT6: 1227445590 +driver_MSLUT7: 4211234 +driver_W0: 2 +driver_W1: 1 +driver_W2: 1 +driver_W3: 1 +driver_X1: 128 +driver_X2: 255 +driver_X3: 255 +driver_START_SIN: 0 +driver_START_SIN90: 247 +driver_IHOLDDELAY: 8 +driver_TPOWERDOWN: 0 +driver_TBL: 1 +driver_TOFF: 4 +driver_HEND: 7 +driver_HSTRT: 0 +driver_VHIGHFS: 0 +driver_VHIGHCHM: 0 +driver_PWM_AUTOSCALE: True +driver_PWM_FREQ: 1 +driver_PWM_GRAD: 4 +driver_PWM_AMPL: 128 +driver_SGT: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +driver_SFILT: 0 +interpolate: True +sense_resistor: 0.110 +stealthchop_threshold: 0 +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 8 +driver_TPOWERDOWN: 20 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 0 +driver_HSTRT: 5 +driver_PWM_AUTOGRAD: True +driver_PWM_AUTOSCALE: True +driver_PWM_LIM: 12 +driver_PWM_REG: 8 +driver_PWM_FREQ: 1 +driver_PWM_GRAD: 14 +driver_PWM_OFS: 36 +interpolate: True +sense_resistor: 0.110 +stealthchop_threshold: 0 +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 8 +driver_TPOWERDOWN: 20 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 0 +driver_HSTRT: 5 +driver_PWM_AUTOGRAD: True +driver_PWM_AUTOSCALE: True +driver_PWM_LIM: 12 +driver_PWM_REG: 8 +driver_PWM_FREQ: 1 +driver_PWM_GRAD: 14 +driver_PWM_OFS: 36 +driver_SGTHRS: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +spi_speed: 4000000 +interpolate: True +idle_current_percent: 100 +driver_TBL: 2 +driver_RNDTF: 0 +driver_HDEC: 0 +driver_CHM: 0 +driver_HEND: 3 +driver_HSTRT: 3 +driver_TOFF: 4 +driver_SEIMIN: 0 +driver_SEDN: 0 +driver_SEMAX: 0 +driver_SEUP: 0 +driver_SEMIN: 0 +driver_SFILT: 0 +driver_SGT: 0 +driver_SLPH: 0 +driver_SLPL: 0 +driver_DISS2G: 0 +driver_TS2G: 3 +interpolate: True +rref: 12000 +stealthchop_threshold: 0 +driver_MSLUT0: 2863314260 +driver_MSLUT1: 1251300522 +driver_MSLUT2: 608774441 +driver_MSLUT3: 269500962 +driver_MSLUT4: 4227858431 +driver_MSLUT5: 3048961917 +driver_MSLUT6: 1227445590 +driver_MSLUT7: 4211234 +driver_W0: 2 +driver_W1: 1 +driver_W2: 1 +driver_W3: 1 +driver_X1: 128 +driver_X2: 255 +driver_X3: 255 +driver_START_SIN: 0 +driver_START_SIN90: 247 +driver_OFFSET_SIN90: 0 +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 6 +driver_IRUNDELAY: 4 +driver_TPOWERDOWN: 10 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 2 +driver_HSTRT: 5 +driver_FD3: 0 +driver_TPFD: 4 +driver_CHM: 0 +driver_VHIGHFS: 0 +driver_VHIGHCHM: 0 +driver_DISS2G: 0 +driver_DISS2VS: 0 +driver_PWM_AUTOSCALE: True +driver_PWM_AUTOGRAD: True +driver_PWM_FREQ: 0 +driver_FREEWHEEL: 0 +driver_PWM_GRAD: 0 +driver_PWM_OFS: 29 +driver_PWM_REG: 4 +driver_PWM_LIM: 12 +driver_SGT: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +driver_SFILT: 0 +driver_SG4_ANGLE_OFFSET: 1 +interpolate: True +sense_resistor: 0.075 +stealthchop_threshold: 0 +driver_MSLUT0: 2863314260 +driver_MSLUT1: 1251300522 +driver_MSLUT2: 608774441 +driver_MSLUT3: 269500962 +driver_MSLUT4: 4227858431 +driver_MSLUT5: 3048961917 +driver_MSLUT6: 1227445590 +driver_MSLUT7: 4211234 +driver_W0: 2 +driver_W1: 1 +driver_W2: 1 +driver_W3: 1 +driver_X1: 128 +driver_X2: 255 +driver_X3: 255 +driver_START_SIN: 0 +driver_START_SIN90: 247 +driver_MULTISTEP_FILT: True +driver_IHOLDDELAY: 6 +driver_TPOWERDOWN: 10 +driver_TBL: 2 +driver_TOFF: 3 +driver_HEND: 2 +driver_HSTRT: 5 +driver_FD3: 0 +driver_TPFD: 4 +driver_CHM: 0 +driver_VHIGHFS: 0 +driver_VHIGHCHM: 0 +driver_DISS2G: 0 +driver_DISS2VS: 0 +driver_PWM_AUTOSCALE: True +driver_PWM_AUTOGRAD: True +driver_PWM_FREQ: 0 +driver_FREEWHEEL: 0 +driver_PWM_GRAD: 0 +driver_PWM_OFS: 30 +driver_PWM_REG: 4 +driver_PWM_LIM: 12 +driver_SGT: 0 +driver_SEMIN: 0 +driver_SEUP: 0 +driver_SEMAX: 0 +driver_SEDN: 0 +driver_SEIMIN: 0 +driver_SFILT: 0 +driver_DRVSTRENGTH: 0 +driver_BBMCLKS: 4 +driver_BBMTIME: 0 +driver_FILT_ISENSE: 0 +i2c_address: 96 +analog_pullup_resistor: 4700 +lcd_type: hd44780 +hd44780_protocol_init: True +lcd_type: hd44780_spi +hd44780_protocol_init: True +lcd_type: st7920 +lcd_type: emulated_st7920 +lcd_type: uc1701 +vcomh: 0 +invert: False +x_offset: 0 +type: disabled +type: list +type: command +type: input +pause_on_runout: True +event_delay: 3.0 +pause_delay: 0.5 +detection_length: 7.0 +default_nominal_filament_diameter: 1.75 +max_difference: 0.2 +measurement_delay: 100 +cal_dia1: 1.50 +cal_dia2: 2.00 +raw_dia1: 9500 +raw_dia2: 10500 +default_nominal_filament_diameter: 1.75 +max_difference: 0.200 +measurement_delay: 70 +enable: False +measurement_interval: 10 +logging: False +min_diameter: 1.0 +use_current_dia_while_delay: False +sensor_type: hx711 +gain: A-128 +sample_rate: 80 +sensor_type: hx717 +gain: A-128 +sample_rate: 320 +sensor_type: ads1220 +spi_speed: 512000 +gain: 128 +sample_rate: 660 +smooth_time: 2.0 +enable_pin: !gpio0_20 +standstill_power_down: False +baud: 115200 +feedrate_splice: 0.8 +feedrate_normal: 1.0 +auto_load_speed: 2 +auto_cancel_variation: 0.1 +sample_period: 0.000400 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_data/non_matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_data/non_matching_data.txt new file mode 100644 index 0000000..582572b --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_data/non_matching_data.txt @@ -0,0 +1,37 @@ +[section] +[section with spaces] +[section with spaces and comments] ; comment 1 +[section with spaces and comments] # comment 2 + indented_option: value +option_with_no_value: +another_option_with_no_value: + indented_option_with_no_value: +# position_min: 0 +# homing_speed: 5.0 + +### this is a comment +; this is also a comment +# [section] +# [section with spaces] +# [section with spaces and comments] ; comment 1 +;[section] +;[section with spaces] +;[section with spaces and comments] ; comment 1 +# commented_option: value +#commented_option: value +;commented_option: value +; commented_option: value +# +; +option_1 :: value +option_1:: value +option_1 ::value +option_2 == value +option_2== value +option_2 ==value +option_1 := value +option_1:= value +option_1 :=value +option_2 := value +option_2:= value +option_2 :=value diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_match_option.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_match_option.py new file mode 100644 index 0000000..5dba4a0 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option/test_match_option.py @@ -0,0 +1,39 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # + +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import SimpleConfigParser +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.joinpath("test_data") +MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("matching_data.txt") +NON_MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("non_matching_data.txt") + + +@pytest.fixture +def parser(): + return SimpleConfigParser() + + +@pytest.mark.parametrize("line", load_testdata_from_file(MATCHING_TEST_DATA_PATH)) +def test_match_option(parser, line): + """Test that a line matches the definition of an option""" + assert ( + parser._match_option(line) is True + ), f"Expected line '{line}' to match option definition!" + + +@pytest.mark.parametrize("line", load_testdata_from_file(NON_MATCHING_TEST_DATA_PATH)) +def test_non_matching_option(parser, line): + """Test that a line does not match the definition of an option""" + assert ( + parser._match_option(line) is False + ), f"Expected line '{line}' to not match option definition!" diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_data/matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_data/matching_data.txt new file mode 100644 index 0000000..89d43f2 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_data/matching_data.txt @@ -0,0 +1,15 @@ +trusted_clients: +gcode: +cors_domains: +an_options_block_start_with_comment: ; this is a comment +an_options_block_start_with_comment: # this is a comment +options_block_start_with_comment:;this is a comment +options_block_start_with_comment :;this is a comment +options_block_start_with_comment:#this is a comment +options_block_start_with_comment :#this is a comment +parameter_temperature_(°C): +parameter_temperature_(°C)= +parameter_humidity_(%_RH): +parameter_humidity_(%_RH) : +parameter_spool_weight_(%): +parameter_spool_weight_(%) = diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_data/non_matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_data/non_matching_data.txt new file mode 100644 index 0000000..02da2de --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_data/non_matching_data.txt @@ -0,0 +1,31 @@ +type: jsonfile +path: /dev/shm/drying_box.json +baud: 250000 +minimum_cruise_ratio: 0.5 +square_corner_velocity: 5.0 +full_steps_per_rotation: 200 +position_min: 0 +homing_speed: 5.0 +# baud: 250000 +# minimum_cruise_ratio: 0.5 +# square_corner_velocity: 5.0 +# full_steps_per_rotation: 200 +# position_min: 0 +# homing_speed: 5.0 + +### this is a comment +; this is also a comment +; +# +homing_speed:: +homing_speed:: +homing_speed :: +homing_speed :: +homing_speed== +homing_speed== +homing_speed == +homing_speed == +homing_speed := +homing_speed := +homing_speed =: +homing_speed =: diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_match_options_block_start.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_match_options_block_start.py new file mode 100644 index 0000000..904b2f7 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_option_block_start/test_match_options_block_start.py @@ -0,0 +1,39 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # + +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import SimpleConfigParser +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.joinpath("test_data") +MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("matching_data.txt") +NON_MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("non_matching_data.txt") + + +@pytest.fixture +def parser(): + return SimpleConfigParser() + + +@pytest.mark.parametrize("line", load_testdata_from_file(MATCHING_TEST_DATA_PATH)) +def test_match_options_block_start(parser, line): + """Test that a line matches the definition of an options block start""" + assert ( + parser._match_options_block_start(line) is True + ), f"Expected line '{line}' to match options block start definition!" + + +@pytest.mark.parametrize("line", load_testdata_from_file(NON_MATCHING_TEST_DATA_PATH)) +def test_non_matching_options_block_start(parser, line): + """Test that a line does not match the definition of an options block start""" + assert ( + parser._match_options_block_start(line) is False + ), f"Expected line '{line}' to not match options block start definition!" diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/__init__,py.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/__init__,py.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_data/matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_data/matching_data.txt new file mode 100644 index 0000000..a3e335a --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_data/matching_data.txt @@ -0,0 +1,127 @@ +[example_section] +[gcode_macro CANCEL_PRINT] +[gcode_macro SET_PAUSE_NEXT_LAYER] +[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL] +[update_manager moonraker-obico] +[include moonraker_obico_macros.cfg] +[include moonraker-obico-update.cfg] +[example_section two] +[valid_content] +[valid content] +[content123] +[a] +[valid_content] # comment +[something];comment +[mcu] +[printer] +[printer] +[stepper_x] +[stepper_y] +[stepper_z] +[printer] +[stepper_a] +[stepper_b] +[stepper_c] +[delta_calibrate] +[printer] +[stepper_left] +[stepper_right] +[stepper_bed] +[stepper_arm] +[delta_calibrate] +[extruder] +[heater_bed] +[bed_mesh] +[bed_tilt] +[bed_screws] +[screws_tilt_adjust] +[z_tilt] +[quad_gantry_level] +[skew_correction] +[z_thermal_adjust] +[safe_z_home] +[homing_override] +[endstop_phase stepper_z] +[gcode_macro my_cmd] +[delayed_gcode my_delayed_gcode] +[save_variables] +[idle_timeout] +[virtual_sdcard] +[sdcard_loop] +[force_move] +[pause_resume] +[firmware_retraction] +[gcode_arcs] +[respond] +[exclude_object] +[input_shaper] +[adxl345] +[lis2dw] +[mpu9250 my_accelerometer] +[resonance_tester] +[board_pins my_aliases] +[duplicate_pin_override] +[probe] +[bltouch] +[smart_effector] +[probe_eddy_current my_eddy_probe] +[axis_twist_compensation] +[stepper_z1] +[extruder1] +[dual_carriage] +[extruder_stepper my_extra_stepper] +[manual_stepper my_stepper] +[verify_heater heater_config_name] +[homing_heaters] +[thermistor my_thermistor] +[adc_temperature my_sensor] +[heater_generic my_generic_heater] +[temperature_sensor my_sensor] +[temperature_probe my_probe] +[fan] +[heater_fan heatbreak_cooling_fan] +[controller_fan my_controller_fan] +[temperature_fan my_temp_fan] +[fan_generic extruder_partfan] +[led my_led] +[neopixel my_neopixel] +[dotstar my_dotstar] +[pca9533 my_pca9533] +[pca9632 my_pca9632] +[servo my_servo] +[gcode_button my_gcode_button] +[output_pin my_pin] +[pwm_tool my_tool] +[pwm_cycle_time my_pin] +[static_digital_output my_output_pins] +[multi_pin my_multi_pin] +[tmc2130 stepper_x] +[tmc2208 stepper_x] +[tmc2209 stepper_x] +[tmc2660 stepper_x] +[tmc2240 stepper_x] +[tmc5160 stepper_x] +[ad5206 my_digipot] +[mcp4451 my_digipot] +[mcp4728 my_dac] +[mcp4018 my_digipot] +[display] +[display_data my_group_name my_data_name] +[display_template my_template_name] +[display_glyph my_display_glyph] +[menu __some_list __some_name] +[menu some_name] +[menu some_list] +[menu some_list some_command] +[menu some_list some_input] +[filament_switch_sensor my_sensor] +[filament_motion_sensor my_sensor] +[tsl1401cl_filament_width_sensor] +[hall_filament_width_sensor] +[load_cell] +[sx1509 my_sx1509] +[samd_sercom my_sercom] +[adc_scaled my_name] +[replicape] +[palette2] +[angle my_angle_sensor] diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_data/non_matching_data.txt b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_data/non_matching_data.txt new file mode 100644 index 0000000..42371ab --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_data/non_matching_data.txt @@ -0,0 +1,19 @@ +section: invalid +not_a_valid_section +[missing_square_bracket +missing_square_bracket] +[] +[ ] + [indented_section] + [indented_section] # comment + [indented_section] ; comment +;[commented_section] +#[another_commented_section] +; [commented_section] +# [another_commented_section] +this_is_an_option: 123 + this_is_an_indented_option: 123 +this_is_an_option_block_start: + +# +; diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_match_section.py b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_match_section.py new file mode 100644 index 0000000..e950dd2 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_matching/match_section/test_match_section.py @@ -0,0 +1,39 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # + +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import SimpleConfigParser +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.joinpath("test_data") +MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("matching_data.txt") +NON_MATCHING_TEST_DATA_PATH = BASE_DIR.joinpath("non_matching_data.txt") + + +@pytest.fixture +def parser(): + return SimpleConfigParser() + + +@pytest.mark.parametrize("line", load_testdata_from_file(MATCHING_TEST_DATA_PATH)) +def test_match_section(parser, line): + """Test that a line matches the definition of a section""" + assert ( + parser._match_section(line) is True + ), f"Expected line '{line}' to match section definition!" + + +@pytest.mark.parametrize("line", load_testdata_from_file(NON_MATCHING_TEST_DATA_PATH)) +def test_non_matching_section(parser, line): + """Test that a line does not match the definition of a section""" + assert ( + parser._match_section(line) is False + ), f"Expected line '{line}' to not match section definition!" diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_parsing/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/line_parsing/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/line_parsing/test_line_parsing.py b/kiauh/core/submodules/simple_config_parser/tests/line_parsing/test_line_parsing.py new file mode 100644 index 0000000..e1b95d5 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/line_parsing/test_line_parsing.py @@ -0,0 +1,62 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +from pathlib import Path + +import pytest + +from src.simple_config_parser.constants import HEADER_IDENT +from src.simple_config_parser.simple_config_parser import SimpleConfigParser +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.parent.joinpath("assets") +TEST_DATA_PATH = BASE_DIR.joinpath("test_config_1.cfg") + + +@pytest.fixture +def parser(): + parser = SimpleConfigParser() + for line in load_testdata_from_file(TEST_DATA_PATH): + parser._parse_line(line) # noqa + + return parser + + +def test_section_parsing(parser): + expected_keys = {"section_1", "section_2", "section_3", "section_4"} + assert expected_keys.issubset( + parser.config.keys() + ), f"Expected keys: {expected_keys}, got: {parser.config.keys()}" + assert parser.in_option_block is False + assert parser.current_section == "section number 5" + assert parser.config["section_2"]["_raw"] == "[section_2] ; comment" + + +def test_option_parsing(parser): + assert parser.config["section_1"]["option_1"]["value"] == "value_1" + assert parser.config["section_1"]["option_1"]["_raw"] == "option_1: value_1" + assert parser.config["section_3"]["option_3"]["value"] == "value_3" + assert ( + parser.config["section_3"]["option_3"]["_raw"] == "option_3: value_3 # comment" + ) + + +def test_header_parsing(parser): + header = parser.config[HEADER_IDENT] + assert isinstance(header, list) + assert len(header) > 0 + + +def test_collector_parsing(parser): + section = "section_2" + section_content = list(parser.config[section].keys()) + coll_name = [name for name in section_content if name.startswith("#_")][0] + collector = parser.config[section][coll_name] + assert collector is not None + assert isinstance(collector, list) + assert len(collector) > 0 + assert "; comment" in collector diff --git a/kiauh/core/submodules/simple_config_parser/tests/public_api/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/public_api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/public_api/test_options_api.py b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_options_api.py new file mode 100644 index 0000000..352e556 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_options_api.py @@ -0,0 +1,189 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import ( + NoOptionError, + NoSectionError, + SimpleConfigParser, +) +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.parent.joinpath("assets") +TEST_DATA_PATH = BASE_DIR.joinpath("test_config_1.cfg") + + +@pytest.fixture +def parser(): + parser = SimpleConfigParser() + for line in load_testdata_from_file(TEST_DATA_PATH): + parser._parse_line(line) # noqa + + return parser + + +def test_get_options(parser): + expected_options = { + "section_1": {"option_1"}, + "section_2": {"option_2"}, + "section_3": {"option_3"}, + "section_4": {"option_4"}, + "section number 5": {"option_5", "multi_option", "option_5_1"}, + } + + for section, options in expected_options.items(): + assert options.issubset( + parser.get_options(section) + ), f"Expected options: {options} in section: {section}, got: {parser.get_options(section)}" + assert "_raw" not in parser.get_options(section) + assert all( + not option.startswith("#_") for option in parser.get_options(section) + ) + + +def test_has_option(parser): + assert parser.has_option("section_1", "option_1") is True + assert parser.has_option("section_1", "option_128") is False + # section does not exist: + assert parser.has_option("section_128", "option_1") is False + + +def test_getval(parser): + # test regular option values + assert parser.getval("section_1", "option_1") == "value_1" + assert parser.getval("section_3", "option_3") == "value_3" + assert parser.getval("section_4", "option_4") == "value_4" + assert parser.getval("section number 5", "option_5") == "this.is.value-5" + assert parser.getval("section number 5", "option_5_1") == "value_5_1" + assert parser.getval("section_2", "option_2") == "value_2" + + # test multiline option values + ml_val = parser.getval("section number 5", "multi_option") + assert isinstance(ml_val, list) + assert len(ml_val) > 0 + + +def test_getval_fallback(parser): + assert parser.getval("section_1", "option_128", "fallback") == "fallback" + + +def test_getval_exceptions(parser): + with pytest.raises(NoSectionError): + parser.getval("section_128", "option_1") + + with pytest.raises(NoOptionError): + parser.getval("section_1", "option_128") + + +def test_getint(parser): + value = parser.getint("section_1", "option_1_2") + assert isinstance(value, int) + + +def test_getint_from_val(parser): + with pytest.raises(ValueError): + parser.getint("section_1", "option_1") + + +def test_getint_from_float(parser): + with pytest.raises(ValueError): + parser.getint("section_1", "option_1_3") + + +def test_getint_from_boolean(parser): + with pytest.raises(ValueError): + parser.getint("section_1", "option_1_1") + + +def test_getint_fallback(parser): + assert parser.getint("section_1", "option_128", 128) == 128 + + +def test_getboolean(parser): + value = parser.getboolean("section_1", "option_1_1") + assert isinstance(value, bool) + assert value is True or value is False + + +def test_getboolean_from_val(parser): + with pytest.raises(ValueError): + parser.getboolean("section_1", "option_1") + + +def test_getboolean_from_int(parser): + with pytest.raises(ValueError): + parser.getboolean("section_1", "option_1_2") + + +def test_getboolean_from_float(parser): + with pytest.raises(ValueError): + parser.getboolean("section_1", "option_1_3") + + +def test_getboolean_fallback(parser): + assert parser.getboolean("section_1", "option_128", True) is True + assert parser.getboolean("section_1", "option_128", False) is False + + +def test_getfloat(parser): + value = parser.getfloat("section_1", "option_1_3") + assert isinstance(value, float) + + +def test_getfloat_from_val(parser): + with pytest.raises(ValueError): + parser.getfloat("section_1", "option_1") + + +def test_getfloat_from_int(parser): + value = parser.getfloat("section_1", "option_1_2") + assert isinstance(value, float) + + +def test_getfloat_from_boolean(parser): + with pytest.raises(ValueError): + parser.getfloat("section_1", "option_1_1") + + +def test_getfloat_fallback(parser): + assert parser.getfloat("section_1", "option_128", 1.234) == 1.234 + + +def test_set_existing_option(parser): + parser.set_option("section_1", "new_option", "new_value") + assert parser.getval("section_1", "new_option") == "new_value" + assert parser.config["section_1"]["new_option"]["_raw"] == "new_option: new_value\n" + + parser.set_option("section_1", "new_option", "new_value_2") + assert parser.getval("section_1", "new_option") == "new_value_2" + assert ( + parser.config["section_1"]["new_option"]["_raw"] == "new_option: new_value_2\n" + ) + + +def test_set_new_option(parser): + parser.set_option("new_section", "very_new_option", "very_new_value") + assert ( + parser.has_section("new_section") is True + ), f"Expected 'new_section' in {parser.get_sections()}" + assert parser.getval("new_section", "very_new_option") == "very_new_value" + + parser.set_option("section_2", "array_option", ["value_1", "value_2", "value_3"]) + assert parser.getval("section_2", "array_option") == [ + "value_1", + "value_2", + "value_3", + ] + assert parser.config["section_2"]["array_option"]["_raw"] == "array_option:\n" + + +def test_remove_option(parser): + parser.remove_option("section_1", "option_1") + assert parser.has_option("section_1", "option_1") is False diff --git a/kiauh/core/submodules/simple_config_parser/tests/public_api/test_read_file.py b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_read_file.py new file mode 100644 index 0000000..b8b523b --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_read_file.py @@ -0,0 +1,28 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import ( + SimpleConfigParser, +) + +BASE_DIR = Path(__file__).parent.parent.joinpath("assets") +TEST_DATA_PATH = BASE_DIR.joinpath("test_config_1.cfg") + + +@pytest.fixture +def parser(): + return SimpleConfigParser() + + +def test_read_file(parser): + parser.read_file(TEST_DATA_PATH) + assert parser.config is not None + assert parser.config.keys() is not None diff --git a/kiauh/core/submodules/simple_config_parser/tests/public_api/test_sections_api.py b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_sections_api.py new file mode 100644 index 0000000..0e55ecf --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_sections_api.py @@ -0,0 +1,81 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import ( + DuplicateSectionError, + SimpleConfigParser, +) +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.parent.joinpath("assets") +TEST_DATA_PATH = BASE_DIR.joinpath("test_config_1.cfg") + + +@pytest.fixture +def parser(): + parser = SimpleConfigParser() + for line in load_testdata_from_file(TEST_DATA_PATH): + parser._parse_line(line) # noqa + + return parser + + +def test_get_sections(parser): + expected_keys = { + "section_1", + "section_2", + "section_3", + "section_4", + "section number 5", + } + assert expected_keys.issubset( + parser.get_sections() + ), f"Expected keys: {expected_keys}, got: {parser.get_sections()}" + + +def test_has_section(parser): + assert parser.has_section("section_1") is True + assert parser.has_section("not_available") is False + + +def test_add_section(parser): + pre_add_count = len(parser.get_sections()) + parser.add_section("new_section") + parser.add_section("new_section2") + assert parser.has_section("new_section") is True + assert parser.has_section("new_section2") is True + assert len(parser.get_sections()) == pre_add_count + 2 + + new_section = parser.config["new_section"] + assert isinstance(new_section, dict) + assert new_section["_raw"] == "[new_section]\n" + + # this should be the collector, added by the parser before + # then second section was added + assert list(new_section.keys())[-1].startswith("#_") + assert "\n" in new_section[list(new_section.keys())[-1]] + + new_section2 = parser.config["new_section2"] + assert isinstance(new_section2, dict) + assert new_section2["_raw"] == "[new_section2]\n" + + +def test_add_section_duplicate(parser): + with pytest.raises(DuplicateSectionError): + parser.add_section("section_1") + + +def test_remove_section(parser): + pre_remove_count = len(parser.get_sections()) + parser.remove_section("section_1") + assert parser.has_section("section_1") is False + assert len(parser.get_sections()) == pre_remove_count - 1 + assert "section_1" not in parser.config diff --git a/kiauh/core/submodules/simple_config_parser/tests/public_api/test_write_file.py b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_write_file.py new file mode 100644 index 0000000..1bde3fa --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/public_api/test_write_file.py @@ -0,0 +1,41 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import ( + SimpleConfigParser, +) + +BASE_DIR = Path(__file__).parent.parent.joinpath("assets") +TEST_DATA_PATH = BASE_DIR.joinpath("test_config_1.cfg") +# TEST_DATA_PATH_2 = BASE_DIR.joinpath("test_config_1_write.cfg") + + +def test_write_file_exception(): + parser = SimpleConfigParser() + with pytest.raises(ValueError): + parser.write_file(None) # noqa + + +def test_write_to_file(tmp_path): + tmp_file = Path(tmp_path).joinpath("tmp_config.cfg") + parser1 = SimpleConfigParser() + parser1.read_file(TEST_DATA_PATH) + # parser1.write_file(TEST_DATA_PATH_2) + parser1.write_file(tmp_file) + + parser2 = SimpleConfigParser() + parser2.read_file(tmp_file) + + assert tmp_file.exists() + assert parser2.config is not None + + with open(TEST_DATA_PATH, "r") as original, open(tmp_file, "r") as written: + assert original.read() == written.read() diff --git a/kiauh/core/submodules/simple_config_parser/tests/utils.py b/kiauh/core/submodules/simple_config_parser/tests/utils.py new file mode 100644 index 0000000..91299cf --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/utils.py @@ -0,0 +1,15 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +from pathlib import Path + + +def load_testdata_from_file(file_path: Path): + """Helper function to load test data from a text file""" + + with open(file_path, "r") as f: + return [line.replace("\n", "") for line in f] diff --git a/kiauh/core/submodules/simple_config_parser/tests/value_conversion/__init__.py b/kiauh/core/submodules/simple_config_parser/tests/value_conversion/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kiauh/core/submodules/simple_config_parser/tests/value_conversion/test_get_conv.py b/kiauh/core/submodules/simple_config_parser/tests/value_conversion/test_get_conv.py new file mode 100644 index 0000000..47828c2 --- /dev/null +++ b/kiauh/core/submodules/simple_config_parser/tests/value_conversion/test_get_conv.py @@ -0,0 +1,74 @@ +# ======================================================================= # +# Copyright (C) 2024 Dominik Willner # +# # +# https://github.com/dw-0/simple-config-parser # +# # +# This file may be distributed under the terms of the GNU GPLv3 license # +# ======================================================================= # +from pathlib import Path + +import pytest + +from src.simple_config_parser.simple_config_parser import SimpleConfigParser +from tests.utils import load_testdata_from_file + +BASE_DIR = Path(__file__).parent.parent.joinpath("assets") +TEST_DATA_PATH = BASE_DIR.joinpath("test_config_1.cfg") + + +@pytest.fixture +def parser(): + parser = SimpleConfigParser() + for line in load_testdata_from_file(TEST_DATA_PATH): + parser._parse_line(line) # noqa + + return parser + + +def test_get_conv(parser): + # Test conversion to int + should_be_int = parser._get_conv("section_1", "option_1_2", int) + assert isinstance(should_be_int, int) + + # Test conversion to float + should_be_float = parser._get_conv("section_1", "option_1_3", float) + assert isinstance(should_be_float, float) + + # Test conversion to boolean + should_be_bool = parser._get_conv( + "section_1", "option_1_1", parser._convert_to_boolean + ) + assert isinstance(should_be_bool, bool) + + # Test fallback for int + should_be_fallback_int = parser._get_conv( + "section_1", "option_128", int, fallback=128 + ) + assert isinstance(should_be_fallback_int, int) + assert should_be_fallback_int == 128 + + # Test fallback for float + should_be_fallback_float = parser._get_conv( + "section_1", "option_128", float, fallback=1.234 + ) + assert isinstance(should_be_fallback_float, float) + assert should_be_fallback_float == 1.234 + + # Test fallback for boolean + should_be_fallback_bool = parser._get_conv( + "section_1", "option_128", parser._convert_to_boolean, fallback=True + ) + assert isinstance(should_be_fallback_bool, bool) + assert should_be_fallback_bool is True + + # Test ValueError exception for invalid int conversion + with pytest.raises(ValueError): + parser._get_conv("section_1", "option_1", int) + + # Test ValueError exception for invalid float conversion + with pytest.raises(ValueError): + parser._get_conv("section_1", "option_1", float) + + # Test ValueError exception for invalid boolean conversion + with pytest.raises(ValueError): + parser._get_conv("section_1", "option_1", parser._convert_to_boolean) diff --git a/kiauh/extensions/gcode_shell_cmd/gcode_shell_cmd_extension.py b/kiauh/extensions/gcode_shell_cmd/gcode_shell_cmd_extension.py index 290bc42..0113e1c 100644 --- a/kiauh/extensions/gcode_shell_cmd/gcode_shell_cmd_extension.py +++ b/kiauh/extensions/gcode_shell_cmd/gcode_shell_cmd_extension.py @@ -122,10 +122,10 @@ class GcodeShellCmdExtension(BaseExtension): for cfg_file in cfg_files: Logger.print_status(f"Include shell_command.cfg in '{cfg_file}' ...") scp = SimpleConfigParser() - scp.read(cfg_file) + scp.read_file(cfg_file) if scp.has_section(section): Logger.print_info("Section already defined! Skipping ...") continue scp.add_section(section) - scp.write(cfg_file) + scp.write_file(cfg_file) Logger.print_ok("Done!") diff --git a/kiauh/extensions/obico/moonraker_obico.py b/kiauh/extensions/obico/moonraker_obico.py index 0aa248c..d47e6c4 100644 --- a/kiauh/extensions/obico/moonraker_obico.py +++ b/kiauh/extensions/obico/moonraker_obico.py @@ -141,5 +141,5 @@ class MoonrakerObico: return False scp = SimpleConfigParser() - scp.read(self.cfg_file) - return scp.get("server", "auth_token", None) is not None + scp.read_file(self.cfg_file) + return scp.getval("server", "auth_token", None) is not None diff --git a/kiauh/extensions/obico/moonraker_obico_extension.py b/kiauh/extensions/obico/moonraker_obico_extension.py index e19bd53..02e842d 100644 --- a/kiauh/extensions/obico/moonraker_obico_extension.py +++ b/kiauh/extensions/obico/moonraker_obico_extension.py @@ -281,15 +281,15 @@ class ObicoExtension(BaseExtension): def _patch_obico_cfg(self, moonraker: Moonraker, obico: MoonrakerObico) -> None: scp = SimpleConfigParser() - scp.read(obico.cfg_file) - scp.set("server", "url", self.server_url) - scp.set("moonraker", "port", str(moonraker.port)) - scp.set( + scp.read_file(obico.cfg_file) + scp.set_option("server", "url", self.server_url) + scp.set_option("moonraker", "port", str(moonraker.port)) + scp.set_option( "logging", "path", obico.base.log_dir.joinpath(obico.log_file_name).as_posix(), ) - scp.write(obico.cfg_file) + scp.write_file(obico.cfg_file) def _patch_printer_cfg(self, klipper: List[Klipper]) -> None: add_config_section( diff --git a/kiauh/utils/config_utils.py b/kiauh/utils/config_utils.py index 32f5b9c..1f5179c 100644 --- a/kiauh/utils/config_utils.py +++ b/kiauh/utils/config_utils.py @@ -35,7 +35,7 @@ def add_config_section( continue scp = SimpleConfigParser() - scp.read(cfg_file) + scp.read_file(cfg_file) if scp.has_section(section): Logger.print_info("Section already exist. Skipped ...") continue @@ -44,9 +44,9 @@ def add_config_section( if options is not None: for option in reversed(options): - scp.set(section, option[0], option[1]) + scp.set_option(section, option[0], option[1]) - scp.write(cfg_file) + scp.write_file(cfg_file) def add_config_section_at_top(section: str, instances: List[InstanceType]) -> None: @@ -55,9 +55,9 @@ def add_config_section_at_top(section: str, instances: List[InstanceType]) -> No tmp_cfg = tempfile.NamedTemporaryFile(mode="w", delete=False) tmp_cfg_path = Path(tmp_cfg.name) scp = SimpleConfigParser() - scp.read(tmp_cfg_path) + scp.read_file(tmp_cfg_path) scp.add_section(section) - scp.write(tmp_cfg_path) + scp.write_file(tmp_cfg_path) tmp_cfg.close() cfg_file = instance.cfg_file @@ -80,10 +80,10 @@ def remove_config_section(section: str, instances: List[InstanceType]) -> None: continue scp = SimpleConfigParser() - scp.read(cfg_file) + scp.read_file(cfg_file) if not scp.has_section(section): Logger.print_info("Section does not exist. Skipped ...") continue scp.remove_section(section) - scp.write(cfg_file) + scp.write_file(cfg_file)