diff options
| author | Eugene Triguba <eugenetriguba@gmail.com> | 2020-01-17 15:56:30 -0600 |
|---|---|---|
| committer | Eugene Triguba <eugenetriguba@gmail.com> | 2020-01-17 15:56:30 -0600 |
| commit | 0d59cd78efd53f9f03918e27edbf4b83cb97c66b (patch) | |
| tree | d2585e282a13797b935ada839333185297b4ce0e /config_file | |
| parent | Expose private attrs and methods in base parser (diff) | |
| download | config-file-0d59cd78efd53f9f03918e27edbf4b83cb97c66b.zip | |
Add ini parser and config file object
Diffstat (limited to 'config_file')
| -rw-r--r-- | config_file/__init__.py | 11 | ||||
| -rw-r--r-- | config_file/config_file.py | 71 | ||||
| -rw-r--r-- | config_file/parsers/ini_parser.py | 105 |
3 files changed, 184 insertions, 3 deletions
diff --git a/config_file/__init__.py b/config_file/__init__.py index 6e82ea7..09ec563 100644 --- a/config_file/__init__.py +++ b/config_file/__init__.py @@ -1,5 +1,10 @@ -""" -config_file: Manage your configuration files. -""" +from config_file.config_file import ConfigFile +from config_file.parsers.base_parser import BaseParser, ParsingError __version__ = "0.2.0" + +__all__ = [ + "ConfigFile", + "ParsingError", + "BaseParser", +] diff --git a/config_file/config_file.py b/config_file/config_file.py new file mode 100644 index 0000000..a95aa2d --- /dev/null +++ b/config_file/config_file.py @@ -0,0 +1,71 @@ +from pathlib import Path + +from config_file.parsers.ini_parser import IniParser +from config_file.parsers.base_parser import BaseParser + + +class ConfigFile: + + def __init__(self, file_path: str, parser=None): + self.path = self.__create_config_path(file_path) + + with open(self.path, "r") as file: + self.contents = file.read() + + self.parser = self.__determine_parser(file_path, parser) + + @staticmethod + def __create_config_path(file_path: str): + if len(file_path) > 1 and file_path[0] == "~": + return Path(file_path).expanduser().resolve() + + return Path(file_path) + + def __determine_parser(self, file_path: str, parser): + if isinstance(BaseParser, parser): + return parser(self.contents) + + file_type = self._split_on_dot(file_path, all_dots=True)[-1] + if file_type == "ini": + return IniParser(self.contents) + else: + raise ValueError( + f"File path contains an unsupported or " + f"unrecognized file type: {file_path}" + ) + + def get(self, key, parse_type=True): + """ + Retrieve the value of a key in its native type. + This means the string 'true' will be parsed back as the + boolean True. + + If parse_type is set to False, all values will be returned + back as strings. + """ + return self.parser.get(key, parse_type=parse_type) + + def set(self, key, value): + """Sets the value of a key.""" + return self.parser.set(key, value) + + def delete(self, section_key): + """Deletes a key/value pair or entire sections.""" + return self.parser.delete(section_key) + + def stringify(self) -> str: + """Convert the parsed internal representation of the file back into a string.""" + return self.parser.stringify() + + def has(self, section_key: str) -> bool: + """ + Check if a section, sub-section, or key exists in the file + using a section.key format. + + Some formats, like JSON, do not have sections and therefore, + it would only be checking if the section + """ + return self.parser.has(section_key) + + + diff --git a/config_file/parsers/ini_parser.py b/config_file/parsers/ini_parser.py new file mode 100644 index 0000000..9a69164 --- /dev/null +++ b/config_file/parsers/ini_parser.py @@ -0,0 +1,105 @@ +import configparser +from io import StringIO + +from config_file.parsers.base_parser import BaseParser, ParsingError +from config_file.parsers.parse_value import parse_value + + +class IniParser(BaseParser): + + def __init__(self, file_contents: str): + """Reads in the file contents into the parser.""" + try: + self.parser = configparser.ConfigParser() + super().__init__(file_contents) + except configparser.Error as error: + raise ParsingError(error) + + def parse(self, file_contents: str): + self.parser.read_string(file_contents) + + def get(self, section_key, parse_type=True): + """ + Read the value of `section.key` of the config file. + + :param section_key: The section and key to read from in the config file. + e.g. 'section1.key2' + :param parse_type: Coerces the return value to its native type. + :return: The value of the key, parsed to its native type if parse_type is True. + + :raises ValueError: if the section_key given is not in a dot format. e.g. 'section1.key' + :raises ParsingError: if the specified `section.key` is not found, in an + invalid format, or if we are unable to coerce the return value to value_type. + """ + section, key = self._split_on_dot(section_key) + + try: + value = self.parser.get(section, key) + return parse_value(value) if parse_type else value + except configparser.Error as error: + raise ParsingError(error.message) + + def set(self, section_key, value): + """ + Sets the value of 'section.key' of the config file. If the specified section + is not in the configuration file, it will be created before adding the key + to it. + + :param section_key: The key to set from the config file. e.g. 'section1.key' + :param value: The value to set the key to. + + :return: True if the setting was successful. + :rtype: boolean + + :raises ValueError: If there is no dot (.) in section_key + """ + section, key = self._split_on_dot(section_key) + + if value is not None and not self.parser.has_section(section): + self.parser.add_section(section) + + self.parser.set(section, key, value) + return True + + def delete(self, section_key): + """ + Deletes a key or an entire section. + + :param section_key: The key to delete from the config file. + e.g. 'ocr.engine'. If no dot (.) is present, it will assume you are trying + to delete the entire section. + + :return: True if the deletion succeeded. + :rtype: boolean + + :raise ValueError: If the section or key does not exist in the config file. + """ + if "." not in section_key: + if not self.parser.has_section(section_key): + raise ValueError( + f"Cannot delete {section_key} because it is not in the config file." + ) + + self.parser.remove_section(section_key) + return True + + section, key = self._split_on_dot(section_key) + if key not in self.parser[section]: + raise ValueError( + f"Cannot delete {section}.{key} because {key} is not in {section}." + ) + + self.parser.remove_option(section, key) + return True + + def stringify(self) -> str: + buffer = StringIO() + self.parser.write(buffer) + return buffer.getvalue() + + def has(self, section_key: str) -> bool: + if "." not in section_key: + return self.parser.has_section(section_key) + + section, key = self._split_on_dot(section_key) + return self.parser.has_option(section, key) |