Settings Model to read multiple settings files and writes to one

Question

I am writing a Model to read, write and store settings. I think my code is pretty good, but I am not 100% sure. Any advice on how I could possibly improve it is welcome.

import ntpath

import yaml


class Settings:
    def __init__(self, paths=None, default_path=None):
        """Load, write and store settings

        This model manages setting files (YAML).

        Keyword Arguments:
            paths {list or None} -- list of full or relative
                                    paths with filenames (default: {None})
            default_path {str or None} -- path to user settings, read last
                                          and default for writing
                                          (default: {None})
        """
        paths = paths or []
        # Make sure paths are unique and sorted by file name
        self.paths = sorted(set(paths), key=lambda p: ntpath.basename(p))
        # Remove default_path from paths (look at next comment)
        try:
            self.paths.remove(default_path)
        except ValueError:
            pass
        # Readd default_path at the end to make sure it's loaded last
        if default_path is not None:
            self.paths.append(default_path)
        # Set remaining attributes
        self.default_path = default_path
        self.settings = {}

        # Load files
        self.reload()

    def reload(self):
        """Reload files into buffer

        Reloads the files specified in self.paths
        and writes them into the buffer.
        """
        # Clear settings to ensure no unwanted leftovers
        self.settings.clear()
        # Load every path (sorted by filename, self.default_path last)
        for path in self.paths:
            with open(path, 'r') as f:
                content = f.read()
            self.settings.update(yaml.load(content) or {})

    def write(self, key, value, path=None):
        """Write into file

        Writes key and value into the file specified
        by path (or self.default_path if None)

        Arguments:
            key {immutable} -- key to use (valid YAML key)
            value {ANY} -- value to save

        Keyword Arguments:
            path {str} -- path to save file (default: {None})
        """
        path = path or self.default_path
        assert path is not None

        with open(path, 'r') as f:
            settings = yaml.load(f.read()) or {}

        settings[key] = value
        self.settings[key] = value

        with open(path, 'w') as f:
            f.write(yaml.dump(settings, default_flow_style=False))

Answer 1

The module should import os.path instead of ntpath.

os.path is the cross-platform equivalent of ntpath, it automatically picks the appropriate path module for the OS your code is running on. So it will use ntpath behind the scenes when running on Windows, but you will also be able to use the code on more operating systems than just Windows. (See the note at https://docs.python.org/3/library/os.path.html)

Answer 2

One thing I found so far is to either rename the attribute "settings" to "buffer" (or something similar), or to make Settings inherit from dict (or better from collections.MutableMapping as suggested here). Doing something like this is awkward:

settings_instance.settings['test_key']