RFL.settings 1.0.0__tar.gz

RFL.settings-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: RFL.settings
+Version: 1.0.0
+Summary: Rackslab Foundation Library: settings package
+Author-email: Rémi Palancher <remi@rackslab.io>
+License: GPLv3+
+Project-URL: Homepage, https://github.com/rackslab/RFL
+Project-URL: Bug Tracker, https://github.com/rackslab/RFL/issues
+Keywords: utility,basic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: RFL.core
+Requires-Dist: PyYAML
+
+# RFL: settings package
+
+Manage configuration files settings.

RFL.settings-1.0.0/README.md

@@ -0,0 +1,3 @@
+# RFL: settings package
+
+Manage configuration files settings.

RFL.settings-1.0.0/RFL.settings.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: RFL.settings
+Version: 1.0.0
+Summary: Rackslab Foundation Library: settings package
+Author-email: Rémi Palancher <remi@rackslab.io>
+License: GPLv3+
+Project-URL: Homepage, https://github.com/rackslab/RFL
+Project-URL: Bug Tracker, https://github.com/rackslab/RFL/issues
+Keywords: utility,basic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: RFL.core
+Requires-Dist: PyYAML
+
+# RFL: settings package
+
+Manage configuration files settings.

RFL.settings-1.0.0/RFL.settings.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+RFL.settings.egg-info/PKG-INFO
+RFL.settings.egg-info/SOURCES.txt
+RFL.settings.egg-info/dependency_links.txt
+RFL.settings.egg-info/requires.txt
+RFL.settings.egg-info/top_level.txt
+rfl/settings/__init__.py
+rfl/settings/definition.py
+rfl/settings/errors.py
+rfl/settings/loaders.py
+rfl/tests/__init__.py
+rfl/tests/test_settings.py

RFL.settings-1.0.0/RFL.settings.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

RFL.settings-1.0.0/RFL.settings.egg-info/requires.txt

@@ -0,0 +1,2 @@
+RFL.core
+PyYAML

RFL.settings-1.0.0/RFL.settings.egg-info/top_level.txt

@@ -0,0 +1 @@
+rfl

RFL.settings-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "RFL.settings"
+version = "1.0.0"
+description = "Rackslab Foundation Library: settings package"
+license = {text = "GPLv3+"}
+requires-python = ">=3.6"
+keywords = ["utility", "basic"]
+authors = [
+    {name = "Rémi Palancher", email = "remi@rackslab.io"},
+]
+dependencies = [
+    "RFL.core",
+    "PyYAML",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Systems Administration",
+]
+readme = "README.md"
+
+
+[project.urls]
+"Homepage" = "https://github.com/rackslab/RFL"
+"Bug Tracker" = "https://github.com/rackslab/RFL/issues"
+
+[tool.setuptools.packages.find]
+include = ["rfl.settings*"]

RFL.settings-1.0.0/rfl/settings/__init__.py

@@ -0,0 +1,151 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from pathlib import Path
+import urllib
+
+import logging
+
+from .definition import (
+    SettingsDefinition,
+    SettingsSectionDefinition,
+    SettingsParameterDefinition,
+    SettingsDefinitionLoaderYaml,
+)
+from .loaders import RuntimeSettingsSiteLoader, RuntimeSettingsSiteLoaderIni
+from .errors import SettingsOverrideError
+
+logger = logging.getLogger(__name__)
+
+
+class RuntimeSettingsSection:
+    def __init__(self, section: SettingsSectionDefinition):
+        self._name = section.name
+        for parameter in section.parameters:
+            setattr(self, parameter.name, parameter.default)
+
+
+class RuntimeSettings:
+    def __init__(self, definition: SettingsDefinition):
+        # set to hold all sections names
+        self._sections = set()
+        self._definition = definition
+        for section in definition.sections:
+            o_section = type(
+                f"{self.__class__.__name__}{section.name.capitalize()}",
+                (RuntimeSettingsSection,),
+                dict(),
+            )(section)
+            setattr(self, o_section._name, o_section)
+            self._sections.add(o_section._name)
+
+    def override(self, loader: RuntimeSettingsSiteLoader):
+        # load site ini file and check it matches definition
+        for section_name in loader.content.sections():
+            if not self._definition.has_section(section_name):
+                raise SettingsOverrideError(
+                    f"Section {section_name} loaded in settings overrides is not "
+                    "defined in settings definition"
+                )
+            section = self._definition.section(section_name)
+            for parameter_name in loader.content[section.name]:
+                if not section.has_parameter(parameter_name):
+                    raise SettingsOverrideError(
+                        f"Parameter {parameter_name} loaded in settings overrides is "
+                        f"not defined in section {section.name} of settings definition"
+                    )
+                parameter = section.parameter(parameter_name)
+                self._override_parameter(loader, section, parameter)
+
+        # check required parameters
+        self._check_required()
+
+    def _check_required(self):
+        """Verify that all parameters declared as required in settings definition are
+        properly defined with a real value or raise SettingsOverrideError."""
+        for section in self._definition.sections:
+            for parameter in section.parameters:
+                if (
+                    parameter.required
+                    and getattr(getattr(self, parameter.section), parameter.name)
+                    is None
+                ):
+                    raise SettingsOverrideError(
+                        f"Parameter {str(parameter)} is missing but required in "
+                        "settings overrides"
+                    )
+
+    def _override_parameter(
+        self,
+        loader: RuntimeSettingsSiteLoader,
+        section: SettingsSectionDefinition,
+        parameter: SettingsParameterDefinition,
+    ) -> None:
+        """Load value from INI file, convert it to expected type, verify it is a valid
+        choice and set corresponding object attribute. Special logic is applied for list
+        to iterate over the items."""
+        raw = loader.content[section.name].get(parameter.name)
+        if parameter._type == "list":
+            value = [
+                self._load_parameter_value(parameter, parameter.content, raw)
+                for raw in raw.strip().split("\n")
+            ]
+            for item in value:
+                self._validate_choice(parameter, item)
+        else:
+            value = self._load_parameter_value(parameter, parameter._type, raw)
+            self._validate_choice(parameter, value)
+        setattr(getattr(self, section.name), parameter.name, value)
+
+    def _load_parameter_value(self, parameter, _type: str, raw: str):
+        """Try to convert raw value to expected type or raise SettingsOverrideError."""
+        if _type == "path":
+            # Converting a string to a pathlib.Path basically never fails.
+            return Path(raw)
+        elif _type == "uri":
+            # Converting a string to a urllib.ParseResult basically never fails.
+            return urllib.parse.urlparse(raw)
+        elif _type == "int":
+            try:
+                return int(raw)
+            except ValueError as err:
+                raise SettingsOverrideError(
+                    f"Invalid integer value '{raw}' for {parameter} in site overrides"
+                ) from err
+        elif _type == "float":
+            try:
+                return float(raw)
+            except ValueError as err:
+                raise SettingsOverrideError(
+                    f"Invalid float value '{raw}' for {parameter} in site overrides"
+                ) from err
+        elif _type == "bool":
+            if raw.lower() in ["1", "yes", "true", "on"]:
+                return True
+            elif raw.lower() in ["0", "no", "false", "off"]:
+                return False
+            else:
+                raise SettingsOverrideError(
+                    f"Invalid boolean value '{raw}' for {parameter} in site overrides"
+                )
+        else:
+            # Return unmodified value
+            return raw
+
+    def _validate_choice(self, parameter, value):
+        """Validate value is in parameter choices or raise SettingsOverrideError."""
+        if parameter.choices is not None and value not in parameter.choices:
+            raise SettingsOverrideError(
+                f"Value {value} for parameter {parameter} in site overrides is "
+                f"not one of possible choices {parameter.choices}"
+            )
+
+    def override_ini(self, path: Path) -> None:
+        self.override(RuntimeSettingsSiteLoaderIni(path=path))
+
+    @classmethod
+    def yaml_definition(cls, path: Path):
+        return cls(SettingsDefinition(SettingsDefinitionLoaderYaml(path=path)))

RFL.settings-1.0.0/rfl/settings/definition.py

@@ -0,0 +1,201 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from pathlib import Path
+import urllib
+
+import yaml
+
+from .errors import SettingsDefinitionError
+
+
+class SettingsDefinitionLoader:
+    pass
+
+
+class SettingsDefinitionLoaderYaml(SettingsDefinitionLoader):
+    def __init__(self, raw: str = None, path: Path = None):
+        try:
+            if raw is not None:
+                self.content = yaml.safe_load(raw)
+            elif path is not None:
+                try:
+                    with open(path) as fh:
+                        self.content = yaml.safe_load(fh)
+                except FileNotFoundError as err:
+                    raise SettingsDefinitionError(
+                        f"Settings definition file {path} not found"
+                    ) from err
+            else:
+                raise SettingsDefinitionError(
+                    "Either a raw string value or a path must be given to load YAML "
+                    "settings definition"
+                )
+        except yaml.parser.ParserError as err:
+            raise SettingsDefinitionError(
+                f"Invalid YAML settings definition: {str(err)}"
+            ) from err
+        except yaml.scanner.ScannerError as err:
+            raise SettingsDefinitionError(f"YAML scanner error: {str(err)}") from err
+
+
+class SettingsParameterDefinition:
+    # Map properties that can be found in definition file with corresponding
+    # object attributes names.
+    POSSIBLE_PROPERTIES = {
+        "type": "_type",
+        "content": "content",
+        "default": "default",
+        "choices": "choices",
+        "doc": "doc",
+        "ex": "example",
+        "required": "required",
+    }
+    EXPECTED_TYPES = {
+        "str": str,
+        "int": int,
+        "float": float,
+        "path": Path,
+        "bool": bool,
+        "uri": urllib.parse.ParseResult,
+        "list": list,
+    }
+
+    def __init__(self, section: str, name: str, properties: dict):
+        self.section = section
+        self.name = name
+
+        # Check for unsupported properties
+        unsupported_properties = list(
+            set(properties.keys()).difference(self.POSSIBLE_PROPERTIES.keys())
+        )
+        if len(unsupported_properties):
+            raise SettingsDefinitionError(
+                f"Unsupported properties found for {str(self)}: "
+                f"{','.join(unsupported_properties)}"
+            )
+
+        for _property, attribute in self.POSSIBLE_PROPERTIES.items():
+            value = None
+            if _property in properties:
+                value = properties[_property]
+            setattr(self, attribute, value)
+
+        # Check the type of defined parameter is actually supported
+        if self._type not in self.EXPECTED_TYPES:
+            raise SettingsDefinitionError(
+                f"Unsupported type {self._type} for {str(self)}"
+            )
+
+        # Check content property is defined for list and check content type is actually
+        # supported.
+        if self._type == "list":
+            if "content" not in properties:
+                raise SettingsDefinitionError(
+                    f"List content type for parameter {str(self)} must be defined"
+                )
+            elif self.content not in set(self.EXPECTED_TYPES.keys()) - {"list"}:
+                raise SettingsDefinitionError(
+                    f"Unsupported list content type {self.content} for {str(self)}"
+                )
+        # Check content property is not defined if not list
+        if "content" in properties and self._type != "list":
+            raise SettingsDefinitionError(
+                f"Content property is forbidden for parameter {str(self)} with type "
+                f"{self._type}"
+            )
+
+        # If the default value is defined, convert to the expected type and validate it
+        # is a valid choice.
+        if self.default is not None:
+            if self._type == "list":
+                if not isinstance(self.default, list):
+                    raise SettingsDefinitionError(
+                        f"Default value {self.default} for parameter {str(self)} is "
+                        "not a valid list"
+                    )
+                self.default = [
+                    self._load_default(self.content, default)
+                    for default in self.default
+                ]
+                for item in self.default:
+                    self._validate_choice(item)
+            else:
+                self.default = self._load_default(self._type, self.default)
+                self._validate_choice(self.default)
+
+        if self.required is None:
+            self.required = False
+        elif not isinstance(self.required, bool):
+            raise SettingsDefinitionError(
+                f"Invalid boolean value of {str(self)} required property"
+            )
+
+    def _load_default(self, _type, default):
+        """Verify default has the expected type and convert to advanded type if
+        needed."""
+        if _type == "path":
+            return Path(default)
+        elif _type == "uri":
+            return urllib.parse.urlparse(default)
+        if not isinstance(default, self.EXPECTED_TYPES[_type]):
+            raise SettingsDefinitionError(
+                f"Default value {default} for parameter {str(self)} has not "
+                f"the expected type {_type}"
+            )
+        return default
+
+    def _validate_choice(self, default):
+        """Check default is a valid choice or raise SettingsDefinitionError."""
+        if self.choices is not None and default not in self.choices:
+            raise SettingsDefinitionError(
+                f"Default value {default} for parameter {str(self)} is not "
+                f"one of possible choices {self.choices}"
+            )
+
+    def __str__(self):
+        return f"[{self.section}]>{self.name}"
+
+
+class SettingsSectionDefinition:
+    def __init__(self, section: str, parameters: dict):
+        self.name = section
+        self.parameters = [
+            SettingsParameterDefinition(section, parameter, properties)
+            for parameter, properties in parameters.items()
+        ]
+
+    def has_parameter(self, name: str) -> bool:
+        for parameter in self.parameters:
+            if parameter.name == name:
+                return True
+        return False
+
+    def parameter(self, name: str):
+        for parameter in self.parameters:
+            if parameter.name == name:
+                return parameter
+        return None
+
+
+class SettingsDefinition:
+    def __init__(self, loader: SettingsDefinitionLoader):
+        self.sections = [
+            SettingsSectionDefinition(section, parameters)
+            for section, parameters in loader.content.items()
+        ]
+
+    def has_section(self, name: str) -> bool:
+        for section in self.sections:
+            if section.name == name:
+                return True
+        return False
+
+    def section(self, name: str):
+        for section in self.sections:
+            if section.name == name:
+                return section
+        return None

RFL.settings-1.0.0/rfl/settings/errors.py

@@ -0,0 +1,23 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from rfl.core.errors import RFLError
+
+
+class SettingsError(RFLError):
+    pass
+
+
+class SettingsDefinitionError(SettingsError):
+    pass
+
+
+class SettingsSiteLoaderError(SettingsError):
+    pass
+
+
+class SettingsOverrideError(SettingsError):
+    pass

RFL.settings-1.0.0/rfl/settings/loaders.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import configparser
+from pathlib import Path
+import logging
+
+from .errors import SettingsSiteLoaderError
+
+logger = logging.getLogger(__name__)
+
+
+class RuntimeSettingsSiteLoader:
+    pass
+
+
+class RuntimeSettingsSiteLoaderIni(RuntimeSettingsSiteLoader):
+    def __init__(self, raw: str = None, path: Path = None):
+        self.content = configparser.ConfigParser(
+            interpolation=configparser.ExtendedInterpolation()
+        )
+        try:
+            if raw is not None:
+                logger.debug("Loading site settings in INI format from raw value")
+                self.content.read_string(raw)
+            elif path is not None:
+                logger.debug("Loading site settings file %s", path)
+                self.content.read(path)
+            else:
+                raise SettingsSiteLoaderError(
+                    "Either a raw string value or a path must be given to load site "
+                    "settings"
+                )
+        except configparser.Error as error:
+            raise SettingsSiteLoaderError(error)

RFL.settings-1.0.0/rfl/tests/test_settings.py

@@ -0,0 +1,364 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import unittest
+from pathlib import Path
+
+from rfl.settings.definition import SettingsDefinition, SettingsDefinitionLoaderYaml
+from rfl.settings.loaders import RuntimeSettingsSiteLoaderIni
+from rfl.settings import RuntimeSettings, RuntimeSettingsSection
+
+from rfl.settings.errors import SettingsDefinitionError, SettingsOverrideError
+
+VALID_DEFINITION = """
+---
+section1:
+  param_str:
+    type: str
+    default: value1
+
+section2:
+    param_int:
+        type: int
+        default: 10
+        doc: documentation of param2
+        ex: 500
+        choices:
+        - 10
+        - 100
+        - 500
+    param_path:
+        type: path
+        default: /path/to/file
+        doc: documentation of param3
+        ex: /other/path/to/file
+    param_uri:
+        type: uri
+        default: https://localhost:5900/resources
+    param_float:
+        type: float
+    param_bool:
+        type: bool
+        default: yes
+    param_list:
+        type: list
+        content: str
+        default:
+        - value1
+        - value2
+    param_required:
+        type: str
+        required: true
+"""
+
+VALID_SITE = """
+[section1]
+param_str = site_value1
+
+[section2]
+param_path = /site/path/to/file
+param_list =
+  value3
+  #value4
+  value5
+param_required = required_value
+"""
+
+
+class TestSettingsDefinition(unittest.TestCase):
+    def test_valid_content(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(loader)
+        self.assertTrue(definition.has_section("section1"))
+        self.assertFalse(definition.has_section("unknown"))
+        self.assertTrue(definition.section("section1").has_parameter("param_str"))
+        self.assertFalse(definition.section("section1").has_parameter("unknown"))
+        self.assertEqual(
+            definition.section("section1").parameter("param_str").default, "value1"
+        )
+        self.assertEqual(
+            definition.section("section2").parameter("param_int").example, 500
+        )
+        self.assertEqual(
+            len(definition.section("section2").parameter("param_int").choices), 3
+        )
+        self.assertEqual(
+            definition.section("section2").parameter("param_uri")._type, "uri"
+        )
+
+    def test_invalid_yaml(self):
+        with self.assertRaisesRegex(
+            SettingsDefinitionError, "^Invalid YAML settings definition: "
+        ):
+            SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION + "\n fail")
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^YAML scanner error: mapping values are not allowed here.*",
+        ):
+            SettingsDefinitionLoaderYaml(raw="fail: again: ")
+
+    def test_unsupported_property(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_int"]["unknown"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Unsupported properties found for \[section2\]>param_int: unknown$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_unsupported_type(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_int"]["type"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Unsupported type fail for \[section2\]>param_int$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_required_not_bool(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_required"]["required"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Invalid boolean value of \[section2\]>param_required required property$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_default_invalid_type_int(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_int"]["default"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Default value fail for parameter \[section2\]>param_int has not the "
+            "expected type int$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_default_invalid_type_bool(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_bool"]["default"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Default value fail for parameter \[section2\]>param_bool has not the "
+            "expected type bool$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_default_invalid_choice(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_int"]["default"] = 12
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Default value 12 for parameter \[section2\]>param_int is not one of "
+            "possible choices \[10, 100, 500\]$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_default_invalid_type_list(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_list"]["default"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Default value fail for parameter \[section2\]>param_list is not a valid "
+            "list$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_type_list_without_content(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        del loader.content["section2"]["param_list"]["content"]
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^List content type for parameter \[section2\]>param_list must be defined$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_type_list_invalid_content_type(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_list"]["content"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Unsupported list content type fail for \[section2\]>param_list$",
+        ):
+            SettingsDefinition(loader)
+        loader.content["section2"]["param_list"]["content"] = "list"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Unsupported list content type list for \[section2\]>param_list$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_type_content_on_other_type(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_list"]["type"] = "str"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Content property is forbidden for parameter \[section2\]>param_list with "
+            "type str$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_type_list_invalid_default_type(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_list"]["content"] = "bool"
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Default value value1 for parameter \[section2\]>param_list has not the "
+            "expected type bool$",
+        ):
+            SettingsDefinition(loader)
+
+    def test_type_list_invalid_choice(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        loader.content["section2"]["param_list"]["choices"] = ["value1", "value3"]
+        with self.assertRaisesRegex(
+            SettingsDefinitionError,
+            "^Default value value2 for parameter \[section2\]>param_list is not one of "
+            "possible choices \['value1', 'value3'\]$",
+        ):
+            SettingsDefinition(loader)
+
+
+class TestRuntimeSettings(unittest.TestCase):
+    def test_valid_settings(self):
+        loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(loader)
+        settings = RuntimeSettings(definition)
+        self.assertEqual(settings.section1.param_str, "value1")
+        self.assertEqual(settings.section2.param_int, 10)
+        self.assertEqual(settings.section2.param_path, Path("/path/to/file"))
+        self.assertIsInstance(settings.section2.param_uri, tuple)
+        self.assertEqual(settings.section2.param_uri.scheme, "https")
+        self.assertIsInstance(settings.section1, RuntimeSettingsSection)
+        self.assertEqual(type(settings.section1).__name__, "RuntimeSettingsSection1")
+
+    def test_site_overrides(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        settings.override(site_loader)
+        self.assertEqual(settings.section1.param_str, "site_value1")
+        self.assertEqual(settings.section2.param_path, Path("/site/path/to/file"))
+        self.assertEqual(settings.section2.param_list, ["value3", "value5"])
+
+    def test_site_override_invalid_section(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        site_loader.content["big"] = {}
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Section big loaded in settings overrides is not defined in "
+            "settings definition$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_invalid_parameter(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        site_loader.content["section2"]["unknown"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Parameter unknown loaded in settings overrides is not defined in "
+            "section section2 of settings definition$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_invalid_type_int(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        site_loader.content["section2"]["param_int"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Invalid integer value 'fail' for \[section2\]>param_int in site "
+            "overrides$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_invalid_type_float(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        site_loader.content["section2"]["param_float"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Invalid float value 'fail' for \[section2\]>param_float in site "
+            "overrides$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_invalid_type_bool(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        site_loader.content["section2"]["param_bool"] = "fail"
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Invalid boolean value 'fail' for \[section2\]>param_bool in site "
+            "overrides$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_invalid_choice(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        site_loader.content["section2"]["param_int"] = "12"
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Value 12 for parameter \[section2\]>param_int in site overrides is not "
+            "one of possible choices \[10, 100, 500\]$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_undefined_required(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        del site_loader.content["section2"]["param_required"]
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Parameter \[section2\]>param_required is missing but required in "
+            "settings overrides$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_list_invalid_content_type(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        def_loader.content["section2"]["param_list"]["content"] = "int"
+        def_loader.content["section2"]["param_list"]["default"] = [2, 5]
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Invalid integer value 'value3' for \[section2\]>param_list in site "
+            "overrides$",
+        ):
+            settings.override(site_loader)
+
+    def test_site_override_list_invalid_choice(self):
+        def_loader = SettingsDefinitionLoaderYaml(raw=VALID_DEFINITION)
+        def_loader.content["section2"]["param_list"]["choices"] = ["value1", "value2"]
+        definition = SettingsDefinition(def_loader)
+        settings = RuntimeSettings(definition)
+        site_loader = RuntimeSettingsSiteLoaderIni(VALID_SITE)
+        with self.assertRaisesRegex(
+            SettingsOverrideError,
+            "^Value value3 for parameter \[section2\]>param_list in site overrides is "
+            "not one of possible choices \['value1', 'value2'\]$",
+        ):
+            settings.override(site_loader)

RFL.settings-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+