Source code for qtypy.settings

#!/usr/bin/env python3

"""
Pythonic wrapper for QSettings
"""

import contextlib

from PyQt5 import QtCore


class Settings(QtCore.QSettings):
    """
    Settings class. You can also use this as a context manager so that
    `sync()` is called on exit.
    """

    def __iter__(self):
        """
        Iterating on a Settings object yields all keys
        (recursively). Affected by the current group.
        """
        return self.allKeys().__iter__()

    def __contains__(self, name):
        """Support for the `in` operator"""
        return self.contains(name)

    def __delitem__(self, name):
        """Support for del settings['name']"""
        self.remove(name)

    def __getitem__(self, name):
        return self.value(name)

    def __setitem__(self, name, value):
        self.setValue(name, value)

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.sync()

    def get(self, name, default=None):
        if default is None:
            return self[name]
        return self[name] if name in self else default

    def items(self):
        """
        Yields all key/value pairs (recursively). Affected by the
        current group.
        """
        for key in self:
            yield key, self.value(key)

    def keys(self):
        """
        Yield all child keys. Affected by the current group.
        """
        for key in self.childKeys():
            yield key

    def keyValues(self):
        """
        Yield all child key/value pairs. Affected by the current group.
        """
        for key in self.childKeys():
            yield key, self.value(key)

    def groups(self):
        """
        Yield all child groups. Affected by the current group.
        """
        for group in self.childGroups():
            yield group

    @contextlib.contextmanager
    def grouped(self, name):
        """
        Context manager to enter a settings group. So instead of doing

        .. code-block:: python

          settings.beginGroup('spam')
          try:
              ...
          finally:
              settings.endGroup()

        you can do

        .. code-block:: python

          with settings.grouped('spam'):
              ...
        """
        self.beginGroup(name)
        try:
            yield self
        finally:
            self.endGroup()

    def array(self, name):
        """
        Array support. This is used both to read a settings array
        (through iteration) and to write to it (using `with`). Example
        of reading:

        .. code-block:: python

          for item in settings.array('myarray'):
              spam = item.value('spam')
              eggs = item.value('eggs')

        is equivalent to:

        .. code-block:: python

          for index in range(settings.beginReadArray('myarray')):
              spam = settings.value('spam')
              eggs = settings.value('eggs')
          settings.endArray()

        Example of writing:

        .. code-block:: python

          with settings.array('myarray') as items:
              items.add(spam='spam', eggs='eggs')
              items.add(spam=42, eggs=13)

        is equivalent to:

        .. code-block:: python

          settings.beginWriteArray('myarray')
          settings.setArrayIndex(0)
          settings.setValue('spam', 'spam')
          settings.setValue('eggs', 'eggs')
          settings.setArrayIndex(1)
          settings.setValue('spam', 42)
          settings.setValue('eggs', 13)
          settings.endArray()
        """
        class _Array: # pylint: disable=R0903
            def __init__(self, settings, name):
                self.settings = settings
                self.name = name

            def __enter__(self):
                class Adder: # pylint: disable=R0903
                    def __init__(self, settings):
                        self.settings = settings
                        self.current = 0

                    def add(self, **kwargs):
                        self.settings.setArrayIndex(self.current)
                        self.current += 1
                        for name, value in kwargs.items():
                            self.settings.setValue(name, value)

                self.settings.beginWriteArray(self.name)
                return Adder(self.settings)

            def __exit__(self, *args):
                self.settings.endArray()

            def __iter__(self):
                class Value: # pylint: disable=R0903
                    def __init__(self, items):
                        self.items = items
                    def value(self, name, default=None):
                        return self.items.get(name, default)

                def iterator():
                    size = self.settings.beginReadArray(self.name)
                    try:
                        for i in range(size):
                            self.settings.setArrayIndex(i)
                            yield Value(dict(self.settings.items()))
                    finally:
                        self.settings.endArray()

                return iterator()
        return _Array(self, name)