configparsebetter.py

'''
>>> UNFINISHED PROJECT, DO NOT EDIT <<<
This is an unfinished build of an unreleased project. It is very messy.
This will eventually be released as a fully-fledged Python library.

This version is included purely for compatability purposes and will
inevitably be removed (once it becomes a library).
>>> UNFINISHED PROJECT, DO NOT EDIT <<<


New for Instant-Replay-Suite:
    -added `_ConfigParseBetter.comment` method
    -added custom `RawConfigParser._write_section` method
    -implemented `caseSensitive` parameter
    -added `autosaveOnlyWhenFileDoesNotExist` parameter
    -added `optionFormatCallback` parameter
    -added `ifMissing` to `_ConfigParseBetter.write` method
    -default `section` parameter is now None
        -None now becomes 'general' instead of 'DEFAULTS'
    -remade `_ConfigParseBetter.getSection` for speed
    -simplified `_ConfigParseBetter.load` for speed/clarity
    -added `BOOLEAN_STATES` for direct boolean conversion
    -refactored `BetterSectionProxy.__init__` for speed
    -used more efficient alias method in `_ConfigParseBetter`
    -added aliases to `BetterSectionProxy` for speed
    -`_ConfigParseBetter.loadAllFromSection` changes
        -added `suffix` parameter
        -added `comments` parameter (defaults to False)
        -added alias for self.load for speed
        -changed `returnKey` paramter to `valuesOnly`
            -returning key and value is now the default
    -edited configparser-related parameters for clarity
    -deleted a lot of comments/commented out code
    -remade/refactored most attribute-based magic methods
    -added `KEY_ORDER` for strict ordering while writing
    -added `noInterpolation` and `extendedInterpolation` parameters

New for chatGPT-vidgen:
    -added `remove` load parameter
    -improved consistency of loading and writing iterables
    -`autosave` parameter is now saved to `__autosave`
    -improved ConfigParseBetterQt
        -added QFontComboBox support
        -added `subclasses` dictionary parameter
        -added `autosave` parameter to `write()` and `loadQt()`
            -determines whether or not `__widgets` will be used
            -if None, `__autosave` is used

TODO: % and $ interpolation do not actually need to be escaped. fix this in configparser's classes
TODO: main.cfg.lastdir (without load()) -> "AttributeError: 'NoneType' object has no attribute 'section'"
TODO: case sensitive attribute errors should be clearer
TODO: deal with endless name conflicts (remember, settings are part of __dict__)
TODO: add setting for deleting empty sections on write
TODO: __getattribute__ and __getattr__ should directly call configparser methods
TODO: load() should be able to take callbacks (like 'topleft' to Position.TopLeft in battery.py)
TODO: .load() -> 5.6 sec/million
TODO: option to print out key/value pairs while loading (use logging.debug)
TODO: ability for user to auto-raise error on missing values
TODO: alternate class that always reads from the file?
TODO: alternate class that always WRITES to the file? (_ConfigParseBetter.__setattr__)
TODO: add more filler functions like remove_section
TODO: work out sectionLock with dot notation + load() + etc.
TODO: low memory mode -> bettersectionproxy, attributes, etc.
TODO: errors with capitalization of options with dot notation?
TODO: base load()'s type on fallback or do try/excepts with typecasts?
TODO: function/attribute overhead stuff
TODO: typecasting multi-type lists (hello,500 -> ['hello', 500])
TODO: should "type(???) in ITER_TYPES" be a function with an isinstance for-loop?
TODO: change bsp to something readable
TODO: make sure you can do load('lastdir', '.') and cfg.lastdir = '.'
        - these MUST do the same thing when you load for the first time
TODO: loading something for the first time and then writing immediately does not update the value
TODO: make more parameters like fallback_align/__strip global AND line-by-line
        - will this significantly impact performance? probably not?
TODO: general performance. get rid of proxies? how efficient is saving/assigning?
TODO: finish lowMemoryMode or make subclass
TODO: type(x) in (types) VS. for type in types: isinstance(x)?
TODO: make ConfigparsebetterQt show args and kwargs correctly for __init__
TODO: .name vs .getName()
TODO: keep lower() but DON'T change case in file (very hard -> [OPTIONS] but .options works)
TODO: optional debug messages (search for #print)
TODO: WHOOPSIE --> cfg['general']['something'] = True --> LITERALLY CANNOT WORK
        - cfg['something'] = True --> also wouldn't work
TODO: alternate-data-streams (ADS) -> https://www.daniweb.com/programming/tutorials/523626/creating-a-gui-wrapper-for-vlc-media-player-in-python-wxpython
TODO: add warning or fix for "stripvalues + delimiter ending in ' ' + ambiguous length" combo
TODO: way of performing action to each value, like "key" parameter in sort (like doing os.path.exists on every string in a list)
TODO: should this just... be configparser? like instead of wrapping it, just edit configparser.py itself?

From main.pyw:
    - advanced radio button support (with min(max()))?
    - method for saving those things with the sliders like in BDL
    > POSSIBLE SOLUTIONS:
        > bite the bullet and get rid of OptionProxies? people will just have to do x = cfg.x and then cfg.x = x.
            - autosave involves just saving every attribute to its name with its own value
                - use generators to map expected typings to their actual types?
                    - recreate 2 generators everytime new load()'s are called
                        - one generator is the names of all values
                        - the other is the expected type for each corresponding value
            - add if-statement in __setattr__ that autosaves/writes edits
        > use __getattribute__ to directly intervene and get/set .value for items that are OptionProxies
            - this solves most problems, but introduces two new ones:
                - Proxies are no longer mutable in the reasonable sense (UNFIXABLE)
                - People who want to access the proxies themselves must use alternate methods
                    like .copy() or .proxy() or .get() or some other garbage
    - val_type to just type?
    - delimiter_type to list/tuple as default?
    - what is delimiter_type in save()?
    - better min_len and max_len -> use slicing to cut off unwanted parts with max_len?
    - change __types to __listtypes or something
    - align_with_fallback should also fill in default values based on index
    - improve the way empty values for delimited lists are handled. should the fallback just take over immediately?
        - is that how it already works?
'''

import os
import sys
import logging
#import traceback
import configparser

logger = logging.getLogger('CPB')
#from inspect import getframeinfo, stack
#def info(*args, sep=' '):   # TODO remove this, temporary print() fixup
#    caller = getframeinfo(stack()[1][0])
#    log = sep.join(str(arg).lstrip() for arg in args)
#    logger.info(f'{caller.function:<11} [{caller.lineno:<3}] - {log}')
GENERATOR_TYPE = type(_ for _ in ())
ITER_TYPES = (GENERATOR_TYPE, list, tuple, set)
CAST_TYPES = (int, float)
BOOLEAN_STATES = configparser.RawConfigParser.BOOLEAN_STATES

# TODO: global KEY_ORDER vs. property (global means order can break with multiple parsers running, but who does that?)
# TODO: should we ALWAYS assume users will only make one parser? maybe have a subclass for allowing multiple?
NEWLINES_BETWEEN_SECTIONS = 2
KEY_ORDER = []
_append_to_key_order = KEY_ORDER.append


def _write_section(self, fp, section_name, section_items, delimiter):
    ''' Modified version of `configparser.RawConfigParser._write_section`
        that supports comments and strict ordering. '''
    # TODO: do the "strict ordering" part
    comment_prefixes = self._comment_prefixes
    comment_prefix = comment_prefixes[0] if comment_prefixes else False
    interpolate_before = self._interpolation.before_write
    allow_no_value = self._allow_no_value
    get_order_index = KEY_ORDER.index

    fp.write(f'[{section_name}]\n')
    #print('\nWRITING SECTION:', section_name, section_items)

    def align_to_order(pair):
        try: return get_order_index(section_name + pair[0])
        except: return len(section_items)

    for key, value in sorted(section_items, key=align_to_order):
        value = interpolate_before(self, section_name, key, value)
        try: is_comment = key.lstrip()[:len(comment_prefix)] == comment_prefix
        except: is_comment = False

        if is_comment:  # if comment is blank, don't write the prefix
            if key.strip() == comment_prefix: fp.write('\n')
            else: fp.write(key + '\n')
        else:
            if value is not None or not allow_no_value:
                value = delimiter + str(value).replace('\n', '\n\t')
            else:
                value = ''
            fp.write(f'{key}{value}\n')
    fp.write('\n' * NEWLINES_BETWEEN_SECTIONS)

configparser.RawConfigParser._write_section = _write_section



class LockedNameException(Exception):   # TODO finish this
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return f'Option name "{self.name}" is not allowed ' \
               '(__parser, __section, __filepath, ' \
               '__sectionLock, __defaultExtension).'

class SetSectionToValueError(Exception):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return f'Setting a section ("{self.name}") to a value is not allowed.'

class InvalidSectionError(Exception):
    def __init__(self, name, caller):
        self.name = name
        self.caller = caller
    def __str__(self):
        return f'{self.caller}: "{self.name}" is not a valid section.'



class OptionProxy:
    __slots__ = ('section', 'sectionDict', 'name')      # OptionProxies do not dynamically store values like BSP and CPB do

    def __init__(self, name, section_proxy, delimiter):
        self.section = section_proxy
        self.sectionDict = section_proxy.__dict__
        #self.sectionDict = self.section.__dict__
        self.name = name
        #self.delimiter = delimiter     # TODO use this? requires much more in-depth autosave

    def set(self, value):
        self.sectionDict[self.name] = value

    @property
    def value(self):
        #print('OptionProxy.value:', self.name, self.section, self.sectionDict)
        return self.sectionDict[self.name]

    #def __getitem__(self, key): return self.value[key]
    #def __setitem__(self, key, val): self.value[key] = val
    #def __call__(self, *args, **kwargs): return self.value(*args, **kwargs)
    #def __contains__(self, val): return val in self.value
    #def __add__(self, other): return self.value + (other.value if isinstance(other, OptionProxy) else other)
    def __str__(self): return str(self.value)
    #def __repr__(self): return self.value      # causes crashes



# FIXME: BSPs likely need to be manually handled when renaming/deleting sections
class BetterSectionProxy:
    def __init__(self, parent, section):    # this is idiotic
        parser = parent._ConfigParseBetter__parser
        self.__parent = parent
        self.__parser = parser
        self.__caseSensitive = parent._ConfigParseBetter__caseSensitive
        self.__section = parser[section]

    @property
    def name(self):
        ''' Name may or may not be accessible on initialization. '''
        return self.__section.name

    def get(self, key):                     # TODO slow. should this even exist?
        return self.__getattr__(key)

    def getSettings(self):
        return dict(self.__parser.items(self.name))

    def __getitem__(self, key):
        #try: return self.__parser[key]      # this is commented out in twitch CPB (GOOD.)
        #except: return None
        try: return self.__dict__[key]
        except:
            try: return self.__parser[key]
            except: return None
        #try: return self.__getattr__(key)   # TODO twitch CPB
        #except:
        #    try: return self.__parser[key]
        #    except: return None

    def __setitem__(self, key, value):
        #self.__parser[key] = value
        #print('\n\n\nSETTING ITEM', key, value, self.__section)
        self.__setattr__(key, value)               # TODO twitch CPB

    def __setattr__(self, name, value):
        if name[:19] != '_BetterSectionProxy':
            if self.__caseSensitive: name = name.lower()
            self.__parent.save(name, value, section=self.__section)
            self.__dict__[name] = value
        else: self.__dict__[name] = value

    def __getattr__(self, name):    # handles dot notation when `name` does not exist
        # TODO this is still too different from the base __getattr__ implementations
        #print('BSP GETATTR (irs version):', name)
        if not self.__caseSensitive and not name.islower():
            name = name.lower()
            try: return self.__dict__[name]
            except KeyError: pass

        try: value = self.__parent.__dict__[name]
        except KeyError: value = self.__parent.loadFrom(self.name, name)
        self.__dict__[name] = value
        return value

    def __contains__(self, other): return other in self.__dict__    # used near the end of _ConfigParseBetter.load()
    def __str__(self): return f'{self.name}: {self.getSettings()}'
    #def __repr__(self): return str(self.value)                     # causes crashes



class _ConfigParseBetter:
    def __init__(self, filepath=None, parser=None,
                 autoread=True, autosave=True, appdata=False,
                 section=None, stripValues=False,
                 autoUnpackLen1Lists=True, defaultExtension='.ini',
                 defaultDelimiter=',', defaultValType=None,
                 sectionLock=False, caseSensitive=False,
                 lowMemoryMode=False, autosaveCallback=True,
                 autosaveOnlyWhenFileDoesNotExist=False,
                 optionFormatCallback=None,
                 encoding=None, noInterpolation=False,
                 extendedInterpolation=True, **parserkwargs):
        self.__autosave = autosave      # currently only used in ConfigParseBetterQt
        self.__sectionLock = sectionLock
        self.__caseSensitive = caseSensitive
        #self.__errorForMissingFallbacks = True  # TODO unused
        self.__stripValues = stripValues
        self.__autoUnpackLen1Lists = autoUnpackLen1Lists
        self.__defaultExtension = defaultExtension
        self.__defaultDelimiter = defaultDelimiter
        #self.__defaultValType = defaultValType  # TODO unused
        #self.__lowMemoryMode = lowMemoryMode    # TODO unused
        self.__encoding = encoding

        #self.__locked = tuple(self.__dict__.keys())     # TODO unused (use soon)
        #print(self.__locked, end='\n\n')

        # add default parser if none is given, with specified interpolation
        if parser is None:
            if noInterpolation: interpolation = configparser.BasicInterpolation()
            elif extendedInterpolation: interpolation = configparser.ExtendedInterpolation()
            else: interpolation = configparser._UNSET
            parser = configparser.ConfigParser(interpolation=interpolation, **parserkwargs)
        self.__parser = parser
        #parser.parent = self                    # allow parser to reference us

        # `optionxform` is normally used for lowering option names before
        # working on them. If `caseSensitive` is True, we don't want this.
        # NOTE: We must set the function BEFORE we read the file
        if caseSensitive or optionFormatCallback:
            if optionFormatCallback:
                parser.optionxform = optionFormatCallback
            else: parser.optionxform = lambda option: option

        if section: self.__section = section
        else: self.__section = 'general'        # TODO i need to understand the DEFAULTS section better

        # TODO this needs to be improved (in general)
        # TODO warn user if self.read returns 0 read files
        # TODO override RawConfigParser.read() for better error handling?
        self.__filepath = filepath
        if not filepath:
            if sys.argv[0]:
                self.__filepath = sys.argv[0].split('\\')[-1][:-3]
            else:
                if appdata:
                    import inspect
                    caller = inspect.stack()[-1][0].f_code.co_filename
                    base = os.path.splitext(os.path.basename(caller))[0]
                    self.__filepath = os.path.join(base, 'config')
                else:
                    self.__filepath = 'config'
        self.__filepath = self.createConfigPath(appdata=appdata)
        if autoread: self.read(self.__filepath, section, encoding=encoding)

        # False -> no callback; True or None -> default callback
        if (autosave or autosaveOnlyWhenFileDoesNotExist) and autosaveCallback is not False:
            import atexit
            if autosaveCallback is not True and autosaveCallback is not None:   # custom callback specified
                if type(autosaveCallback) in ITER_TYPES:      # callback is an array with arguments
                    kwargs_index = -1
                    for index, arg in enumerate(autosaveCallback):
                        if isinstance(arg, dict):
                            kwargs_index = index
                            break
                    if kwargs_index != -1:      # keyword arguments detected
                        if kwargs_index == 1:   # only keyword arguments detected
                            atexit.register(autosaveCallback[0],
                                            **autosaveCallback[1:])
                        else:                   # positional and keyword arguments detected
                            atexit.register(autosaveCallback[0],
                                            *autosaveCallback[1:kwargs_index],
                                            **autosaveCallback[kwargs_index:])
                    else:                       # no keyword arguments detected
                        atexit.register(autosaveCallback[0],
                                        *autosaveCallback[1:])
                else: atexit.register(autosaveCallback)     # callback includes no arguments
            else: atexit.register(              # use default callback (self.write)
                self.write,
                appdata=appdata,
                ifMissing=autosaveOnlyWhenFileDoesNotExist
            )

        # aliases, for speed TODO: some of these are TOO redundant
        # I wanted to do multiple versions of __getattr__ here but...
        # ...you can't actually have instance-specific magic methods.
        self.__getRawParserSections = parser.sections
        _ConfigParseBetter.deleteSection = self.removeSection
        _ConfigParseBetter.delete_section = self.removeSection
        _ConfigParseBetter.remove_section = self.removeSection
        _ConfigParseBetter.read_dict = parser.read_dict
        _ConfigParseBetter.read_file = parser.read_file
        _ConfigParseBetter.read_string = parser.read_string


    def createConfigPath(self, path=None, appdata=False):
        path = path if path else self.__filepath
        path = os.path.normpath(path)
        if appdata:
            appdatapath = os.path.expandvars('%LOCALAPPDATA%')
            if not path.lower().startswith(appdatapath.lower()):
                path = os.path.join(appdatapath, path)
        dirs, name = os.path.split(path)
        if dirs and not os.path.exists(dirs):
            os.makedirs(dirs)
        if name[-4:] not in ('.ini', '.cfg'):
            name += self.__defaultExtension
        return os.path.join(dirs, name)


    def read(self, filepath=None, setSection=None, **kwargs):
        if setSection is not None: self.setSection(setSection)
        filepath = filepath or self.__filepath
        encoding = kwargs.get('encoding', self.__encoding)
        return self.__parser.read(filepath, encoding=encoding)


    def write(self, filepath=None, mode='w',
              appdata=False, ifMissing=False, **kwargs):
        filepath = self.createConfigPath(filepath, appdata) if filepath else self.__filepath
        if ifMissing and os.path.exists(filepath): return
        encoding = kwargs.get('encoding', self.__encoding)

        logger.debug('Writing ConfigParseBetter config.')
        with open(filepath, mode, encoding=encoding) as configfile:
            self.__parser.write(configfile)
        # -- Outdated version --
        #if (self.__autosave if autosave is None else autosave):     # attempt to auto-save all sections and their options
        #    for section_name in self.sections():
        #        for option in self.__parser.options(section_name):
        #            try:
        #                values = self.__dict__[section_name].__dict__[option]
        #                if type(values) in ITER_TYPES:    # unpack values
        #                    self.save(
        #                        option,
        #                        *values,
        #                        section=section_name
        #                    )
        #                else:                               # leave values as is
        #                    self.save(
        #                        option,
        #                        values,
        #                        section=section_name
        #                    )
        #            except KeyError: pass
        #            #section = self.__dict__[section_name]
        #            #section.__dict__[option] = section.__dict__[option]
        #    #for key, value in self.__dict__.items():
        #    #    if (key[:18] != '_configparsebetter' and
        #    #        not isinstance(value, BetterSectionProxy)):
        #    #        self.save(key, value)
        #with open(filepath, 'w') as configfile: self.__parser.write(configfile)

        # -- Twitch CPB version --
        #if (self.__autoSave if autoSave is None else autoSave):
        #    for section_name in self.sections():
        #        for option in self.__parser.options(section_name):
        #            try:
        #                info(section_name, option, self.__dict__[section_name].__dict__[option])
        #                self.save(
        #                    option,
        #                    self.__dict__[section_name].__dict__[option].value,
        #                    section=section_name
        #                )
        #            except KeyError: pass
        #            #section = self.__dict__[section_name]
        #            #section.__dict__[option] = section.__dict__[option]
        #    #for key, value in self.__dict__.items():
        #    #    if (key[:18] != '_configparsebetter' and
        #    #        not isinstance(value, BetterSectionProxy)):
        #    #        self.save(key, value)
        #path = self.createConfigPath(filepath, appdata) if filepath else self.__filepath
        #with open(path, 'w') as configfile: self.__parser.write(configfile)


    #def refresh(self, newParser=None, autoread=True, encoding=None, **parserkwargs):
    #    ''' Deletes/replaces an old configparser object with a new one. '''
    #    oldSection = self.__dict__['_ConfigParseBetter__section'].name
    #    del self.__parser
    #    self.__parser = newParser or configparser.ConfigParser(**parserkwargs)
    #    if autoread:
    #        encoding = encoding or self.__encoding
    #        self.read(self.__filepath, encoding=encoding)
    #    self.setSection(oldSection)   # restore previous section, if possible


    #def reset(self, newParser=None, autoread=True, encoding=None, **parserkwargs):
    def reset(self):
        for key in self.__dict__:
            if key[:18] != '_ConfigParseBetter':
                del self.__dict__[key]
        #self.refresh(newParser, autoread, encoding, **parserkwargs)


    def comment(self, comment='', before='', after='', section=None):
        ''' Adds a `comment` to the config file. If `comment` is empty,
            a blank line is added instead. Otherwise, the comment will
            be prefixed by the first string specified in the parser's
            `comment_prefixes` parameter (`('#', ';')` by default).
            `before` and `after` define strings that should be added
            before and after the comment, such as newlines. '''
        section = self.getSection(section)
        prefixes = self.__parser._comment_prefixes
        if not prefixes and comment:
            raise ValueError(
                'Please specify `comment_prefixes` for '
                'your parser object to use comments.'
            )

        # add prefix and a space to start of every line
        prefix = prefixes[0] + ' '
        multiline_prefix = '\n' + prefix
        lines = comment.split('\n')
        comment = before + prefix + multiline_prefix.join(lines) + after
        self.__parser._sections[section.name][comment] = None

        # add comment to our key order so we remember its position
        order_key = section.name + comment
        if order_key not in KEY_ORDER:
            _append_to_key_order(order_key)


    # TODO: using an iterable fallback with a custom delimiter should not be allowed (too complicated for now)
    #       - when implemented, it should detect/set appropriate params -> delimiter, val_type. but it's more involved than that
    def load(self, key, fallback='', delimiter=None,        # TODO should delimiter_type and val_type switch places?
             val_type=None, delimiter_type=None,
             fallback_align=True, force_delimiter_type=True,
             min_len=None, max_len=None, fill_with_defaults=False,
             fill_with_fallback=False, default=None,
             aliases=None, remove='', section=None):

        # get fallback's type and verify fallback's actual value
        if isinstance(fallback, type):      # check if fallback is a literal type, like "fallback=int"
            fallback_type = fallback
            #fallback = fallback()          # get default value for that type (i.e. int() = 0)
            fallback = ''                   # TODO why was this needed? _empty_fallback (below)?
            if val_type is None:
                val_type = fallback_type
        else:
            fallback_type = type(fallback)
        fallback_is_iterable = fallback_type in ITER_TYPES
        if fallback_is_iterable and delimiter is None:
            delimiter = self.__defaultDelimiter

        #section, value = self._load(key, fallback, fallback_type, delimiter, section)
        if not self.__caseSensitive: key = key.lower()

        # TODO This block here was originally a separate function called _load, but it's been moved here for optimization
        if key[:3] == '__': raise LockedNameException(key)
        section = self.getSection(section)
        section_name = section.name

        # add key to our key order so we remember its position
        order_key = section_name + key
        if order_key not in KEY_ORDER:
            _append_to_key_order(order_key)

        if section_name in self.__getRawParserSections():
            try:
                value = section.get(key, fallback=fallback)
                if fallback_type == bool:           # getboolean
                    value = BOOLEAN_STATES[value.lower()]
                elif fallback_type in CAST_TYPES:   # getint/getfloat
                    value = fallback_type(value)
            except:
                value = fallback
        elif not self.__sectionLock:
            value = self._loadFromAnywhere(key, fallback)
        else:
            value = fallback    # TODO add elif for raising error here?

        #print('Value before setting within parser:', key, value, type(value))

        # TODO string conversion should probably happen when we do .get() above
        # set the actual RawConfigParser section value (RawConfigParser.set())
        # convert iterable values to string and convert back later to cover most edge-cases
        if not fallback_is_iterable: parser_value = str(value)
        else: parser_value = value = str(value).strip('()[]{}')
        for char in remove: parser_value = value = value.replace(char, '')
        #if strip: parser_value = value = value.strip(strip)
        #elif lstrip: parser_value = value = value.lstrip(lstrip)
        #elif rstrip: parser_value = value = value.rstrip(rstrip)

        # TODO this eventually results in __parser.get(), right? why not just use that
        #section[key] = parser_value.replace('%', '%%')   # 1.0595 sec/million TODO these % signs are for a nightmare https://stackoverflow.com/questions/46156125/how-to-use-signs-in-configparser-python
        section[key] = parser_value
        logger.debug(f'Loading: key={key} -> value={value} ({type(value)}) | fallback={fallback} delim={delimiter} val_type={val_type} delim_type={delimiter_type}')

        #try:                                   # TODO throw more errors here
        # TODO: what is the "aliases" parameter for?
        if aliases: true_value = aliases.get(value, fallback)     # TODO FIXME: should this use `default` instead?
        else: true_value = value
        #key = key.lower()
        #print('true_value:', true_value)

        # there is nothing for us to actually write -> cleanup and return early
        if not true_value and not fallback and delimiter_type is None and true_value == fallback:
            #print('not true_value and not fallback and true_value == fallback')
            #key = key.lower()
            bsp = self.getBetterSectionProxy(section)
            option_proxy = OptionProxy(key, bsp, delimiter)
            self.__dict__[key] = option_proxy
            #self.__dict__[section.name].__dict__[key] = value
            bsp.__dict__[key] = true_value      # TODO should these all be value here and not true_value?
            #return option_proxy
            return true_value

        # double check if we have a delimiter yet -> is so, value is going to be split into a list
        if delimiter is None:
            if val_type is not None:
                true_value = val_type(true_value)
        else:
            #print(f'value={value} type={fallback_type} fallback={fallback} type={type(fallback)}')
            if delimiter_type is None:
                if fallback_is_iterable:
                    delimiter_type = fallback_type
                #else:
                #    delimiter_type = list

            fallback_is_empty = fallback == ''
            try:
                #if delimiter_type in ITER_TYPES:  # we want each element to be an iterable
                #    print('here!', delimiter_type, delimiter, value)
                #    #joined_value = delimiter.join(str(v) for v in value)
                #    #print('joined_value:', joined_value)
                #else:
                #    joined_value = str(value)
                #true_value = joined_value.split(delimiter)

                #true_value = (value if value else fallback).split(delimiter)        # TODO add option for preserving empty lists for `value`?
                if value != '': true_value = value.split(delimiter)
                elif not fallback_is_empty: true_value = fallback.split(delimiter)
                else: true_value = []

                #print(f'ABOUT TO SPLIT VALUE: {value}', true_value)
                if val_type:
                    if self.__stripValues:  # strip string values
                        # strip and typecast values to val_type. if failed, fill in with default if specified, otherwise use val_type's default
                        for index, val in enumerate(true_value):
                            try: true_value[index] = val_type(val.strip())
                            except ValueError:
                                if val_type is int:     # TODO test speed of this vs. "if val_type is int and '.' in val" / should this be separate entirely?
                                    try: true_value[index] = int(float(val.strip()))    # int() cannot convert float strings such as "398.0"
                                    except ValueError: true_value[index] = default if default is not None else val_type()   # example: int() = 0
                    else:                   # leave values as-is
                        #print('else', true_value)
                        # typecast values to val_type. if failed, fill in with default if specified, otherwise use val_type's default
                        for index, val in enumerate(true_value):
                            try: true_value[index] = val_type(val)
                            except ValueError:
                                if val_type is int:     # TODO test speed of this vs. "if val_type is int and '.' in val" / should this be separate entirely?
                                    try: true_value[index] = int(float(val))            # int() cannot convert float strings such as "398.0"
                                    except ValueError: true_value[index] = default if default is not None else val_type()   # example: int() = 0

                #fallback_list = true_value     # TODO why was I using this?
                if fallback_is_empty: fallback_list = []
                elif fallback_is_iterable: fallback_list = fallback
                else: fallback_list = fallback.split(delimiter)

                #print('before fallback corrections', true_value, fallback_list)
                if fallback_align:
                    #print(1, true_value)
                    #print('fallback_align', min_len, max_len, value, fallback_list)
                    fill_with_fallback = not fill_with_defaults
                    max_len = len(fallback_list)
                    min_len = len(fallback_list)    # TODO vvv test this with more iterables, with/without needing fallback
                    if val_type is None:            # set each element to excepted type based on position
                        for index in range(len(true_value)):
                            true_value[index] = type(fallback[index])(true_value[index])
                if min_len or max_len:              # TODO these if-statements could be simplified
                    #print(2, true_value)
                    #print(f'min_len={min_len}, max_len={max_len}')
                    if max_len:                     # TODO need a way to only take the last ones
                        true_value = true_value[:max_len]
                    #print(2.1, true_value)
                    if min_len and len(true_value) < min_len:
                        #print(2.15, true_value)
                        if fill_with_defaults:
                            #print(2.2, true_value)
                            while len(true_value) < min_len:
                                true_value.append(default)
                            #print(2.25, true_value)
                        elif fill_with_fallback:
                            #print(2.3, true_value)
                            true_value += fallback_list[len(true_value):]
                            #print(2.35, true_value, fallback_list)
                        else:
                            #print(2.4, true_value)
                            true_value = fallback_list
                #elif not min_len:                   # TODO does unpacking len1lists here really serve a purpose? also actually use unpacklen1lists here is so
                #    print(3, true_value)
                #    if len(true_value) == 1:
                #        true_value = true_value[0]
                #    #elif len(true_value) == 0:     # TODO ??????
                #    #    true_value = joined_value
                #print('\nend of try', true_value)

            except:                                 # TODO this ALL needs more testing
                #print(f'Inner-load error - {traceback.format_exc()}')
                try: true_value = value.split(delimiter)
                except: true_value = value
            if delimiter_type in ITER_TYPES:  # TODO should this be less strict?
                try:
                    #print('delimiter_type being applied', true_value, delimiter_type)
                    true_value = delimiter_type(true_value)
                    if not isinstance(true_value, delimiter_type):
                        raise TypeError
                except TypeError:
                    if   delimiter_type == list:  true_value = [true_value]
                    elif delimiter_type == tuple: true_value = (true_value,)
                    elif delimiter_type == set:   true_value = {true_value}
        #key = key.lower()
        #section_proxy = self.__dict__[section.name]

        bsp = self.getBetterSectionProxy(section)  # TODO redundant? see below
        if key in bsp:                             # TODO this vs. __dict__ performance
            #option_proxy = bsp[key]                # TODO this vs. __dict__ performance
            #print('getting very real value from key', key, '->', bsp[key])
            #bsp[key].set(true_value)
            #print(key, self.__dict__)
            #print(key, self.__dict__[key])
            self.__dict__[key].set(true_value)
            #option_proxy.set(true_value)
        else:
            #option_proxy = OptionProxy(self, bsp, key, true_value)  # <- bad twitch CPB OptionProxies
            option_proxy = OptionProxy(key, bsp, delimiter)
            self.__dict__[key] = option_proxy
            #print('adding very real value to key', key, '->', true_value)
            bsp.__dict__[key] = true_value
            #print(bsp[key], bsp)
        #option_proxy = OptionProxy(key, bsp, delimiter)
        #self.__dict__[key] = option_proxy   # TODO is this line needed inside or outside the else-statement?
        #self.__dict__[key] = section  # 0.1276 sec/million
        #bsp.__dict__[key] = true_value
        #return option_proxy
        #print(key, true_value)
        return true_value
        #except Exception as error: print(f'Outer-load error - {type(error)}: {error}')


    def loadFrom(self, section, key, fallback='', *args, **kwargs):
        return self.load(key, fallback, *args, section=section, **kwargs)


    def loadAllFromSection(self, section=None, fallback='', prefix=None,
                           suffix=None, valuesOnly=False, comments=False):
        ''' Loads all options from a `section` through a generator. If
            `returnKey` is True, both the key and value of each option are
            yielded together, otherwise just the value is yielded. If `prefix`
            and/or `suffix` is specified, only options with matching keys are
            loaded. `fallback` is applied to every loaded option. '''
        # TODO: is there any benefit to this over parser.items(section)?
        # TODO: If load() is called before setSection(), this will start
        #       returning the settings loaded without a section, even
        #       though they should be loaded into the 'DEFAULT' section.
        section = self.getSection(section)
        load = self.load
        comment_prefixes = self.__parser._comment_prefixes
        comment_prefix = comment_prefixes[0] if comment_prefixes else False

        if prefix or suffix:
            # ensure prefix/suffix are valid strings
            if not prefix: prefix = '' if prefix is None else str(prefix)
            if not suffix: suffix = '' if suffix is None else str(suffix)

            i_prefix = len(prefix)
            i_suffix = -len(suffix)
            for key in self.__parser.options(section.name):
                if not comments:
                    if key.lstrip()[:len(comment_prefix)] == comment_prefix:
                        continue
                prefix_matches = key[:i_prefix] == prefix
                suffix_matches = i_suffix == 0 or key[i_suffix:] == suffix
                if prefix_matches and suffix_matches:
                    if valuesOnly: yield load(key, fallback, section=section)
                    else: yield key, load(key, fallback, section=section)
        else:
            for key in self.__parser.options(section.name):
                if not comments:
                    if key.lstrip()[:len(comment_prefix)] == comment_prefix:
                        continue
                if valuesOnly: yield load(key, fallback, section=section)
                else: yield key, load(key, fallback, section=section)


    #def _load(self, key, fallback, fallback_type, delimiter, section=None, verifySection=True):
    #    if key[:3] == '__':
    #        raise LockedNameException(key)
    #    if verifySection:
    #        section = self.getSection(section)
    #    if section.name in self.__getRawParserSections():
    #        try:
    #            #if isinstance(fallback, type):              # fallback is a literal type, like "fallback=int"
    #            #    fallback_type = fallback
    #            #    fallback = fallback()                   # get default value for that type (i.e. int() = 0)
    #            #else:
    #            #    fallback_type = type(fallback)
#
    #            if fallback_type == bool:
    #                return section, section.getboolean(key, fallback=fallback)
    #            elif fallback_type == int:
    #                return section, section.getint(key, fallback=fallback)
    #            elif fallback_type == float:
    #                return section, section.getfloat(key, fallback=fallback)
    #            elif fallback_is_iterable:     # TODO: converting to string and back (bad and stupid)
    #                delimiter = delimiter if delimiter is not None else ','
    #                fallback = delimiter.join(str(v) for v in fallback)
    #            #print(3, 'section', section, 'key', key, 'fallback', fallback, fallback_type)
    #            #print(4, section.get(key, fallback=fallback))
    #            return section, section.get(key, fallback=fallback)
    #        except:
    #            return section, fallback
    #    elif not self.__sectionLock:
    #        return section, self._loadFromAnywhere(key, fallback)
    #    else:
    #        return section, fallback    # TODO add elif for raising error here?


    def _loadFromAnywhere(self, key, fallback):     # TODO this is probably bad
        if not self.__caseSensitive: key = key.lower()
        for section in self.__getRawParserSections():
            for sectionKey in self.__parser.options(section):
                if sectionKey == key:
                    return self.__parser[section][sectionKey]
        return fallback


    def save(self, key, *values, delimiter=None,
             delimiter_type=None, section=None):
        logger.debug(f'Saving: key={key} values={values}, delim={delimiter}')
        if delimiter is None: delimiter = self.__defaultDelimiter
        if isinstance(values, GENERATOR_TYPE): values = tuple(values)    # turn generator into more flexible iterable
        if self.__autoUnpackLen1Lists:
            if len(values) == 1 and type(values[0]) in ITER_TYPES:
                values = values[0]

        section = self.getSection(section)
        #valueStr = delimiter.join(str(v).replace('%', '%%') for v in values)    # TODO more % stuff
        valueStr = delimiter.join(str(v) for v in values)                      # <- original
        #section[key] = valueStr     # TODO do time test here
        self.__parser.set(section.name, key, valueStr)
        if delimiter_type is None:
            if len(values) == 1: self.__dict__[key.lower()].set(values[0])
            else: self.__dict__[key.lower()].set(values)
        else: self.__dict__[key.lower()].set(delimiter_type(values))
        #if delimiter_type is None and len(values) == 1:    # TODO delete this if the above works as expected
        #    self.__dict__[key.lower()] = values[0]
        #elif delimiter_type is not None:
        #    self.__dict__[key.lower()] = delimiter_type(values)
        #else:
        #    self.__dict__[key.lower()] = values

        # TODO twitch CPB. I think this is from before I redid stuff like __setattr__
        #if delimiter_type is None and len(values) == 1:
        #    try: self.__dict__[key.lower()].set(values[0])
        #    except: self.__dict__[key.lower()] = values[0]
        #elif delimiter_type is not None:
        #    try: self.__dict__[key.lower()].set(delimiter_type(values))
        #    except: self.__dict__[key.lower()] = delimiter_type(values)
        #else:
        #    try: self.__dict__[key.lower()].set(values)
        #    except: self.__dict__[key.lower()] = values


    def saveTo(self, section, key, *values,
               delimiter=None, delimiter_type=None):
        if not delimiter: delimiter = self.__defaultDelimiter
        self.save(key, *values, delimiter=delimiter,
                  delimiter_type=delimiter_type, section=section)


    def sections(self, setSection=False, prefix='', suffix='', strict=True):
        # NOTE: prefixes and suffixes may be iterables
        # NOTE: this is intentionally obtuse as an optimization. could be even more extreme with setSection
        if prefix:
            if suffix:
                if strict:
                    for section in self.__getRawParserSections():
                        if section.startswith(prefix) and section.endswith(suffix):
                            if setSection: self.setSection(section)
                            yield section
                else:
                    for section in self.__getRawParserSections():
                        if section.startswith(prefix) or section.endswith(suffix):
                            if setSection: self.setSection(section)
                            yield section
            else:
                for section in self.__getRawParserSections():
                    if section.startswith(prefix):
                        if setSection: self.setSection(section)
                        yield section
        elif suffix:
            for section in self.__getRawParserSections():
                if section.endswith(suffix):
                    if setSection: self.setSection(section)
                    yield section
        elif setSection:        # NOTE: this is slow, but probably worth it for consistency
            for section in self.__getRawParserSections():
                self.setSection(section)
                yield section
        else: return self.__getRawParserSections()


    def setSection(self, section, locked=False):    # TODO finish `locked` parameter
        self.__section = self.getSection(section)


    def getSection(self, section=None) -> configparser.SectionProxy:
        if section is None:
            section = self.__section

        if isinstance(section, configparser.SectionProxy):
            # TODO verify this never results in missing self.__dict__ entry
            return section
        else:
            # aliases, for speed
            section_key = section if self.__caseSensitive else section.lower()
            parser = self.__parser
            _dict = self.__dict__

            # BetterSectionProxy raises KeyError if `section` doesn't exist...
            # ...in parser, so we can kill two birds with one stone here
            try:
                if section not in _dict:
                    _dict[section_key] = BetterSectionProxy(self, section)
            except KeyError:
                parser[section] = {}
                _dict[section_key] = BetterSectionProxy(self, section)
            return parser[section]


    def removeSection(self, section):   # TODO is shortening this to one faster/worth it?
        section = self.getSection(section)
        self.__parser.remove_section(section.name)


    def copySection(self, section, newSection):
        ''' Copies `section` to `newSection` with
            the same options and comments. '''
        section = self.getSection(section)
        newSection = self.getSection(newSection)
        self.setSection(newSection)

        parser_set = self.__parser.set
        new_name = newSection.name
        for key, value in section.items():
            parser_set(new_name, key, value)


    def renameSection(self, section, newSection):
        ''' Renames `section` to `newSection` and cleans
            up any references to `section` afterwards.'''
        section = self.getSection(section)
        newSection = self.getSection(newSection)
        self.setSection(newSection)

        # sections are not stored in our own __dict__
        parser = self.__parser
        parser._sections[newSection.name] = parser._sections[section.name]
        parser._proxies[newSection.name] = parser._proxies[section.name]
        parser.remove_section(section.name)


    def moveSetting(self, oldKey, newSection, newKey=None, oldSection=None, replace=True):
        ''' Moves an option from `oldSection.oldKey` to `newSection.newKey`,
            overwriting `newSection.newKey` if it already exists and `replace`
            is True. If `newKey` is not provided, `newSection.oldKey` is used.
            If `oldSection` is not provided, the current section is used.
            Returns the value of `newSection.newKey` after the move.
            If `oldSection.oldKey` does not exist, None is returned. '''
        old_section = self.getSection(oldSection)
        new_section = self.getSection(newSection)
        old_section_dict: dict = self.__parser._sections[old_section.name]
        new_section_dict: dict = self.__parser._sections[new_section.name]

        # replace the new setting if necessary & get value to return later
        newKey = newKey or oldKey
        already_exists = newKey in new_section_dict
        if replace or not already_exists:
            try: value = self.__dict__[old_section.name].__dict__[oldKey]
            except KeyError: return None
            new_section_dict[newKey] = old_section_dict[oldKey]
        else:   # `already_exists` must be True if we got this far
            value = self.__dict__[new_section.name].__dict__[newKey]
        del old_section_dict[oldKey]

        try:    # replace `old` with `new` within our order
            index = KEY_ORDER.index(old_section.name + oldKey)
            KEY_ORDER.pop(index)
            if not already_exists:
                KEY_ORDER.insert(index, new_section.name + newKey)
        except:
            pass
        return value


    def renameSetting(self, old, new, replace=True, section=None):
        ''' Renames an option from `section.old` to `section.new`, overwriting
            the `new` key if it already exists and `replace` is True. Returns
            the value of `section.new` after the rename. If `section.old`
            does not exist, None is returned. '''
        section = self.getSection(section)
        section_name = section.name
        section_dict = self.__parser._sections[section_name]

        # replace the new setting if necessary & get value to return later
        already_exists = new in section_dict
        if replace or not already_exists:
            try: value = self.__dict__[section_name].__dict__[old]
            except KeyError: return None
            section_dict[new] = section_dict[old]
        else:   # `already_exists` must be True if we got this far
            value = self.__dict__[section_name].__dict__[new]
        del section_dict[old]

        try:    # replace `old` with `new` within our order
            index = KEY_ORDER.index(section_name + old)
            KEY_ORDER.pop(index)
            if not already_exists:
                KEY_ORDER.insert(index, section_name + new)
        except:
            pass
        return value


    def deleteSetting(self, key, section=None):
        section = self.getSection(section)
        section_name = section.name
        section_dict = self.__parser._sections[section_name]
        del section_dict[key]

        try:    # remove from our order
            order_key = section_name + key
            KEY_ORDER.pop(KEY_ORDER.index(order_key))
        except:
            pass


    def setFilepath(self, filepath, appdata=False):
        self.__filepath = self.createConfigPath(filepath, appdata)


    def getFilepath(self):
        return self.__filepath


    def getParser(self):
        return self.__parser


    def getOptions(self, section):
        try:
            section = section if isinstance(section, str) else section.name
            return self.__parser.options(section)
        except:
            raise InvalidSectionError(section, 'getOptions')


    def getItems(self, section):    # TODO FIXME: this probably doesn't work anymore
        try:
            section = section.lower() if isinstance(section, str) else section.name.lower()
            #section = section if isinstance(section, str) else section.name    # TODO <- original (twitch CPB)
            return self.__parser.items(section)
        except:
            raise InvalidSectionError(section, 'getItems')


    def getBetterSectionProxy(self, section=None):
        section = section if section else self.__section
        if isinstance(section, configparser.SectionProxy):  # TODO: counter-intuitive?
            section = section.name
        for bsp in self.getBetterSectionProxies():
            if bsp.name == section:
                return bsp


    def getBetterSectionProxies(self):  # TODO: only used once -> combine with above for performance?
        for val in self.__dict__.values():
            if isinstance(val, BetterSectionProxy):
                yield val


    def getConfigDictionary(self):
        #for key, val in self.__dict__.items():
        #    if isinstance(val, BetterSectionProxy):
        #        print(key, val.getSettings())
        return {key: val.getSettings() for key, val in self.__dict__.items()
                if isinstance(val, BetterSectionProxy)}


    def __getitem__(self, key):             # TODO this is a little unintuitive
        try: return self.__parser[key]
        except: return None


    def __setitem__(self, key, value):
        #self.__parser[key] = value         # this crashes if `val`'s type is unexpected
        self.__setattr__(key, value)


    # TODO these versions are from twitch CPB
    #def __getitem__(self, key):
    #    try: return self.__dict__[key]
    #    except:
    #        #try: return self.__parser[key]
    #        try: return self.__getattr__(key)
    #        except: return None


    def __setattr__(self, name, value):             # TODO horrific performance?
        if name[:18] != '_ConfigParseBetter':
            if type(value) in ITER_TYPES:     # TODO is this part redundant?
                delimiter = self.__defaultDelimiter
                casted_value = delimiter.join(str(v) for v in value)
            else: casted_value = str(value)

            section = self.__dict__[name].section.name
            self.__parser.set(section, name, casted_value)

            # FIXME casesensitive? (cfg.UNDO_LIST = 'whatever')
            #self.__dict__[name.lower()].set(value)    # this is OptionProxy.set (I think)
            self.__dict__[name].set(value)    # this is OptionProxy.set (I think)
            #self.save(name, value)                   # TODO for autowriting after saves
        else: self.__dict__[name] = value


    #def __getattr__case_sensitive(self, name):
    #    ''' Handles getting attributes that don't exist in __dict__ yet. '''
    #    if name in self.__getRawParserSections(): value = BetterSectionProxy(self, name)
    #    else: value = self._loadFromAnywhere(key=name, fallback=None)
    #    self.__dict__[name] = value
    #    return value


    #def __getattr__not_case_sensitive(self, name):
    #    ''' Handles getting attributes that don't exist in __dict__ yet. '''
    #    #if not name.islower(): return self.__getattribute__(name.lower())
    #    if not name.islower():
    #        name = name.lower()
    #        try: return self.__dict__[name]
    #        except KeyError: pass
    #    if name in self.__getRawParserSections(): value = BetterSectionProxy(self, name)
    #    else: value = self._loadFromAnywhere(key=name, fallback=None)
    #    self.__dict__[name.lower()] = value
    #    return value


    def __getattr__(self, name):
        ''' Handles getting attributes that don't exist in __dict__ yet. '''
        if not self.__caseSensitive and not name.islower():
            name = name.lower()
            try: return self.__dict__[name]
            except KeyError: pass
        if name in self.__getRawParserSections(): value = BetterSectionProxy(self, name)
        else: value = self._loadFromAnywhere(key=name, fallback=None)
        self.__dict__[name.lower()] = value     # FIXME is this casesensitive?
        return value


    def __contains__(self, other):
        return other in self.__dict__


    def __enter__(self):
        self.read()
        return self


    def __exit__(self, type, value, traceback):
        self.write()


    #def __repr__(self):                # TODO this causes __getattribute__ to break??
    #    outputs = []
    #    for section, options in self.getConfigDictionary().items():
    #        output = [f"   {section}:"]
    #        for key, value in options.items():
    #            output.append(f'      {key}: {value}')
    #        outputs.append('\n'.join(output))
    #    #outputs = (f'{k} = {json.dumps(v, indent=4)}\n' for k,v in self.getConfigDictionary().items())  # TODO finish this from twitch cpb
    #    newline = '\n\n'
    #    return f'[{self.getFilepath()}]\n\n{newline.join(outputs)}\n'


    def loadQt(self, *args, **kwargs):
        raise NotImplementedError('This class does not support Qt. Use the ConfigParseBetterQt class instead.')


    def saveQt(self, *args, **kwargs):
        raise NotImplementedError('This class does not support Qt. Use the ConfigParseBetterQt class instead.')




class ConfigParseBetter(_ConfigParseBetter):
    def __getattribute__(self, name):   # TODO __repr__ causes this to break??
        ''' Handles getting any attribute at all. '''
        attr = object.__getattribute__(self, name)
        return attr.value if isinstance(attr, OptionProxy) else attr


    def __setattr__(self, name, val):
        attr = self.__dict__.get(name)
        if isinstance(attr, OptionProxy): attr.set(val)
        return super().__setattr__(name, val)




class ConfigParseBetterQt(ConfigParseBetter):   # TODO support Pyside and other PyQt versions
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)       # TODO check typical ram usage of autosave feature
        self.__widgets = []


    def write(self, *args, autosave=None, **kwargs):
        if autosave is None: autosave = self._ConfigParseBetter__autosave
        if autosave and self.__widgets:         # autosave widgets with their parameters before writing
            logger.debug(f'Writing ConfigParseBetterQt config ({len(self.__widgets)} widgets saved).')
            for parameters in reversed(self.__widgets):
                self.saveQt(
                    *parameters[0],             # index 0 is *widgets
                    children=parameters[-7],
                    recursive=parameters[-6],
                    ignore=parameters[-5],
                    extraWidgets=parameters[-4],
                    subclasses=parameters[-3],
                    getComboText=parameters[-2],
                    section=parameters[-1]
                )
        super().write(*args, **kwargs)          # write normally


    def loadQt(self, *widgets, children=True, recursive=True,
               ignore=tuple(), extraWidgets={}, subclasses={},
               getComboText=False, autosave=None, section=None):
        from PyQt5.QtWidgets import QCheckBox, QLineEdit, QSlider, QDial, \
            QComboBox, QFontComboBox, QRadioButton, QPushButton, QSpinBox, \
            QDoubleSpinBox, QGroupBox, QKeySequenceEdit
        from PyQt5.QtGui import QKeySequence, QFont

        if type(ignore) not in ITER_TYPES: ignore = (ignore,)    # ensure ignore parameter is an array
        logger.debug(f'Loading Qt values from {len(widgets)} widget(s)')
        section = self.getSection(section)

        # https://stackoverflow.com/questions/47019802/inheriting-class-attribute-with-double-underscore
        #if self._ConfigParseBetter__autosave:   # remember widget and parameters for autosaving later
        #    self.__widgets.append((widgets, children, recursive, ignore, extraWidgets, subclasses, getComboText, section))
        if autosave is None: autosave = self._ConfigParseBetter__autosave
        if autosave: self.__widgets.append((widgets, children, recursive, ignore, extraWidgets, subclasses, getComboText, section))

        # checkable qactions, font-combobox, datetime
        def actionCheckBox(widget, name):       # not really worth shoving into a lambda
            if not widget.isCheckable(): return
            if not widget.isTristate(): widget.setChecked(self.load(name, widget.isChecked(), section=section))
            else: widget.setCheckState(self.load(name, int(widget.checkState()), section=section))

        def actionFontComboBox(widget, name):   # fromString doesn't return a new QFont
            font = QFont()
            font.fromString(self.load(name, widget.currentFont().toString(), section=section))
            widget.setCurrentFont(font)

        actionValue = lambda w, name: w.setValue(self.load(name, w.value(), section=section))
        actionCheck = lambda w, name: w.setChecked(self.load(name, w.isChecked(), section=section)) if w.isCheckable() else None
        actions = {
            QSpinBox:         actionValue,      # reuse lambdas where applicable
            QDoubleSpinBox:   actionValue,
            QSlider:          actionValue,
            QDial:            actionValue,
            QRadioButton:     actionCheck,
            QGroupBox:        actionCheck,
            QPushButton:      actionCheck,
            QCheckBox:        actionCheckBox,
            QFontComboBox:    actionFontComboBox,
            QLineEdit:        lambda w, name: w.setText(self.load(name, w.text(), section=section)),
            QKeySequenceEdit: lambda w, name: w.setKeySequence(QKeySequence.fromString(self.load(name, w.keySequence().toString(), section=section))),
            QComboBox:        (lambda w, name: w.setCurrentText(self.load(name, w.currentText(), section=section))
                               if getComboText else w.setCurrentIndex(self.load(name, w.currentIndex(), section=section)))
        }

        # create true ignore list
        _ignore = []
        for widget_type in ignore:
            if widget_type in actions: del actions[widget_type]
            elif not isinstance(widget_type, str): _ignore.append(widget_type.objectName())
            else: _ignore.append(widget_type)

        # add extraWidgets -> {widgetType: (name_of_getter_attribute, name_of_setter_attribute)}
        # workaround for a Python bug/oddity involving creating lambdas in iterables
        def get_getter_and_setter(getter, setter):
            return lambda w, name: (getattr(w, setter)(
                self.load(name, getattr(w, getter)(), section=section)))
        for widget_type, (getter, setter) in extraWidgets.items():
            actions[widget_type] = get_getter_and_setter(getter, setter)

        # redirect subclasses to parent's action
        for subclass, parent in subclasses.items():
            if parent in actions:
                actions[subclass] = actions[parent]

        def getWidget(widget, ignore):      # gets and loads a single widget
            if widget in ignore:
                return
            name = widget.objectName()
            if name[:3] == 'qt_' or not name or name in ignore:
                return                      # ignore qt_ prefixes -> special qt things
            widget_type = type(widget)
            if widget_type in actions:
                actions[widget_type](widget, name)

        def getChildren(widget, ignore):    # like getWidget, but recursive. defined separately for performance optimization
            for child in widget.children():
                if child in ignore:
                    continue
                name = child.objectName()
                if name[:3] == 'qt_' or not name or name in ignore:
                    continue                # ignore qt_ prefixes -> special qt things
                widget_type = type(child)
                if widget_type in actions:
                    actions[widget_type](child, name)
                getChildren(child, ignore)

        for widget in widgets:
            getWidget(widget, _ignore)
            if children:
                if recursive:
                    getChildren(widget, _ignore)
                else:
                    for child in widget.children():
                        if child in _ignore:
                            continue
                        name = child.objectName()
                        if name[:3] == 'qt_' or not name or name in _ignore:
                            continue   # ignore qt_ prefixes -> special qt things
                        widget_type = type(child)
                        if widget_type in actions:
                            actions[widget_type](child, name)


    def saveQt(self, *widgets, children=True, recursive=True, ignore=tuple(), extraWidgets={}, subclasses={}, getComboText=False, section=None):
        from PyQt5.QtWidgets import QCheckBox, QLineEdit, QSlider, QDial, \
            QComboBox, QFontComboBox, QRadioButton, QPushButton, QSpinBox, \
            QDoubleSpinBox, QGroupBox, QKeySequenceEdit
        if type(ignore) not in ITER_TYPES: ignore = (ignore,)  # ensure ignore parameter is an array
        section = self.getSection(section)

        actionValue = lambda w, name: self.save(name, w.value(), section=section)
        actionCheck = lambda w, name: self.save(name, w.isChecked(), section=section) if w.isCheckable() else None
        actions = {
            QSpinBox:         actionValue,
            QDoubleSpinBox:   actionValue,
            QSlider:          actionValue,
            QDial:            actionValue,
            QRadioButton:     actionCheck,
            QGroupBox:        actionCheck,
            QPushButton:      actionCheck,
            QCheckBox:        lambda w, name: self.save(name, w.checkState() if w.isTristate() else w.isChecked(), section=section),
            QFontComboBox:    lambda w, name: self.save(name, w.currentFont().toString(), section=section),
            QLineEdit:        lambda w, name: self.save(name, w.text(), section=section),
            QKeySequenceEdit: lambda w, name: self.save(name, w.keySequence().toString(), section=section),
            QComboBox:        (lambda w, name: self.save(name, w.currentText(), section=section)
                               if getComboText else self.save(name, w.currentIndex(), section=section)),
        }

        # create true ignore list
        _ignore = []
        for widget_type in ignore:
            if widget_type in actions: del actions[widget_type]
            elif not isinstance(widget_type, str): _ignore.append(widget_type.objectName())
            else: _ignore.append(widget_type)

        # add extraWidgets -> {widgetType: (name_of_getter_attribute, name_of_setter_attribute)}
        # workaround for a Python bug/oddity involving creating lambdas in iterables
        def get_getter(getter):
            return lambda w, name: self.save(
                name, getattr(w, getter)(), section=section)
        for widget_type, (getter, _) in extraWidgets.items():
            actions[widget_type] = get_getter(getter)

        # redirect subclasses to parent's action
        for subclass, parent in subclasses.items():
            if parent in actions:
                actions[subclass] = actions[parent]

        def getWidget(widget, ignore):
            name = widget.objectName()
            if name[:3] == 'qt_' or not name or name in ignore:
                return                      # ignore qt_ prefixes -> special qt things
            widget_type = type(widget)
            if widget_type in actions:
                actions[widget_type](widget, name)

        def getChildren(widget, ignore):    # TODO is there a faster way to find these widgets by their objectNames?
            for child in widget.children():
                name = child.objectName()
                if not name or name[:3] == 'qt_' or name in ignore:
                    continue                # ignore qt_ prefixes -> special qt things
                widget_type = type(child)
                if widget_type in actions:
                    actions[widget_type](child, name)
                getChildren(child, ignore)

        for widget in widgets:
            getWidget(widget, _ignore)
            if children:
                if recursive:
                    getChildren(widget, _ignore)
                else:
                    for child in widget.children():
                        name = child.objectName()
                        if not name or name[:3] == 'qt_' or name in _ignore:
                            continue        # ignore qt_ prefixes -> special qt things
                        widget_type = type(child)
                        if widget_type in actions:
                            actions[widget_type](child, name)