byoconfig 0.0.1__tar.gz

byoconfig-0.0.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: byoconfig
+Version: 0.0.1
+Summary: A configuration class that supports plugins, multiple file formats, heirarchical configuration, and more.
+Author-email: Cam Ratchford <camratchford@gmail.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: MacOS X
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: PyYAML==6.0.2
+Requires-Dist: toml==0.10.2
+Provides-Extra: development
+Requires-Dist: mkdocs; extra == "development"
+Requires-Dist: mkdocs-material; extra == "development"
+Requires-Dist: ruff; extra == "development"
+Requires-Dist: pytest; extra == "development"
+Requires-Dist: build; extra == "development"
+Requires-Dist: twine; extra == "development"

byoconfig-0.0.1/byo_config/__init__.py

@@ -0,0 +1,4 @@
+from byo_config.sources.file import FileVariableSource
+from .config import Config
+
+__all__ = ['FileVariableSource', 'Config']

byoconfig-0.0.1/byo_config/config.py

@@ -0,0 +1,112 @@
+import logging
+import inspect
+from typing import Optional, Type
+
+from byo_config.sources import (
+    BaseVariableSource,
+    FileVariableSource,
+    EnvVariableSource,
+    FileTypes,
+)
+from byo_config.error import BYOConfigError
+
+__all__ = ['Config']
+
+logger = logging.getLogger(__name__)
+
+
+class Config(FileVariableSource, EnvVariableSource):
+    """
+    A versatile config object that can parse many file types, load environment variables,
+    and load dictionary keys as class attributes.
+      - Multiple config objects from different unique sources can be collated easily with a precedence value.
+      - Config instances with higher precedence have their values overwrite the values of lower precedence
+        instances when merging objects.
+    """
+
+    def __init__(
+            self,
+            source_file_path: Optional[str] = None,
+            forced_file_type: Optional[FileTypes] = None,
+            env_prefix: Optional[str] = None,
+            var_source_name: Optional[str] = "Config",
+            precedence: Optional[int] = 1,
+            **kwargs
+    ):
+        """
+        Initialize a Config object.
+
+        Args:
+            source_file_path (str):
+                The path to the source file.
+
+            forced_file_type (FileTypes):
+                The file type of the source file, if you don't want to use the file's extension.
+
+            var_source_name (str):
+                The name of the variable source.
+
+            env_prefix (str):
+                The configuration keys will be loaded from the environment variables with this prefix.
+                Use the "*" wildcard if you want to load all environment variables as configuration keys.
+
+            precedence (int):
+                The precedence of the variable source.
+
+            **kwargs:
+                Arbitrary keyword arguments, to be loaded as class attributes.
+        """
+        try:
+            self.precedence = precedence
+            self.var_source_name = var_source_name
+            super().__init__(
+                source_file=source_file_path,
+                forced_file_type=forced_file_type
+            )
+            super().load_env(env_prefix)
+
+            self.set_data(kwargs)
+            logger.debug(f"Config object {self.var_source_name} created with precedence {self.precedence}")
+
+        except BYOConfigError as e:
+            raise e
+
+        except FileNotFoundError as e:
+            raise e
+
+        except ValueError as e:
+            raise e
+
+        except Exception as e:
+            raise e
+
+    def include(self, plugin_class: Type[BaseVariableSource], **kwargs):
+        """
+        Include a plugin class in the config object.
+
+        Args:
+            plugin_class (Type[BaseVariableSource]):
+                The plugin class to include in the config object.
+
+            **kwargs:
+                Arbitrary keyword arguments to pass to the plugin class.
+        """
+        try:
+            # get signature of plugin class
+            sig = inspect.signature(plugin_class)
+            # Compare kwargs to signature
+            for k, v in kwargs.items():
+                if k not in sig.parameters:
+                    raise BYOConfigError(
+                        f"Invalid parameter '{k}' for plugin class '{plugin_class.__name__}'",
+                        self
+                    )
+            plugin = plugin_class(**kwargs)  # type: ignore
+            self.set_data(plugin.get_data())
+            logger.debug(f"Initialized plugin '{plugin_class.__name__}' with data: {plugin.get_data()}")
+
+        except BYOConfigError as e:
+            raise e
+
+        except Exception as e:
+            raise e

byoconfig-0.0.1/byo_config/error.py

@@ -0,0 +1,19 @@
+
+__all__ = ['BYOConfigError']
+
+
+class BYOConfigError(ValueError):
+    """Subclass of ValueError with the following additional properties:
+    args:
+        msg:           The unformatted error message
+        instance_name: The name of which VariableSource instance raised the error
+    """
+    def __init__(self, msg, instance):
+        errmsg = f"{msg} in VariableSource instance '{instance.var_source_name}'"
+        super().__init__(self, errmsg)
+        self.msg = msg
+        self.instance = instance.var_source_name
+
+    def __reduce__(self):
+        return self.__class__, (self.msg, self.instance)
+

byoconfig-0.0.1/byoconfig.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: byoconfig
+Version: 0.0.1
+Summary: A configuration class that supports plugins, multiple file formats, heirarchical configuration, and more.
+Author-email: Cam Ratchford <camratchford@gmail.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: MacOS X
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: PyYAML==6.0.2
+Requires-Dist: toml==0.10.2
+Provides-Extra: development
+Requires-Dist: mkdocs; extra == "development"
+Requires-Dist: mkdocs-material; extra == "development"
+Requires-Dist: ruff; extra == "development"
+Requires-Dist: pytest; extra == "development"
+Requires-Dist: build; extra == "development"
+Requires-Dist: twine; extra == "development"

byoconfig-0.0.1/byoconfig.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+byo_config/__init__.py
+byo_config/config.py
+byo_config/error.py
+byoconfig.egg-info/PKG-INFO
+byoconfig.egg-info/SOURCES.txt
+byoconfig.egg-info/dependency_links.txt
+byoconfig.egg-info/requires.txt
+byoconfig.egg-info/top_level.txt
+tests/test_config.py
+tests/test_error.py
+tests/test_sources_base.py
+tests/test_sources_env.py
+tests/test_sources_file.py

byoconfig-0.0.1/byoconfig.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

byoconfig-0.0.1/byoconfig.egg-info/requires.txt

@@ -0,0 +1,10 @@
+PyYAML==6.0.2
+toml==0.10.2
+
+[development]
+mkdocs
+mkdocs-material
+ruff
+pytest
+build
+twine

byoconfig-0.0.1/byoconfig.egg-info/top_level.txt

@@ -0,0 +1 @@
+byo_config

byoconfig-0.0.1/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["byo_config"]
+
+[project]
+name = 'byoconfig'
+description = 'A configuration class that supports plugins, multiple file formats, heirarchical configuration, and more.'
+authors = [
+    {name = 'Cam Ratchford', email = 'camratchford@gmail.com'},
+]
+
+classifiers = [
+    'Development Status :: 3 - Alpha',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: 3 :: Only',
+    'Intended Audience :: Developers',
+    'Intended Audience :: Information Technology',
+    'Operating System :: POSIX :: Linux',
+    'Environment :: Win32 (MS Windows)',
+    'Environment :: MacOS X',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+]
+version = "0.0.1"
+requires-python = '>=3.8'
+dependencies = [
+    "PyYAML==6.0.2",
+    "toml==0.10.2",
+]
+
+[project.optional-dependencies]
+development = [
+    "mkdocs",
+    "mkdocs-material",
+    "ruff",
+    "pytest",
+    "build",
+    "twine"
+]
+
+[tool.ruff]
+exclude = [
+    "tests/fixtures/**/*"
+]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F"]
+ignore = []
+fixable = ["ALL"]
+unfixable = []
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-format = false
+docstring-code-line-length = "dynamic"
+
+[tool.pytest.ini_options]
+addopts = "-ra -q"
+testpaths = [
+    "tests",
+]

byoconfig-0.0.1/setup.cfg

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

byoconfig-0.0.1/tests/test_config.py

@@ -0,0 +1,56 @@
+from os import environ
+from fixtures.pathing import example_configs
+from fixtures.fixture_source_classes import PluginVarSource
+
+from byo_config.config import Config
+
+
+def test_file_var_source_functionality():
+    example_dict = {
+        "parent": {
+            "some": "thing",
+            "child": {
+                "other": "thing"
+            }
+        }
+    }
+
+    yaml_file = str(example_configs / 'same_as.yaml')
+    yaml_source = Config(yaml_file)
+    assert yaml_source.data == example_dict
+
+    toml_file = str(example_configs / 'same_as.toml')
+    toml_source = Config(toml_file)
+    assert toml_source.data == example_dict
+
+    json_file = str(example_configs / 'same_as.json')
+    json_source = Config(json_file)
+    assert json_source.data == example_dict
+
+
+def test_env_var_source_functionality():
+    env_prefix = 'BYO_CONFIG_TEST_'
+    env_var = 'BYO_CONFIG_TEST_ENV_VAR'
+    env_val = 'test_value'
+
+    env_dict = {env_var: env_val}
+    environ.update(env_dict)
+
+    env_source = Config(env_prefix=env_prefix)
+    assert env_source.data.get("ENV_VAR") == environ.get(env_var)
+
+
+def test_loading_plugins_and_kwargs():
+
+    config = Config(
+        precedence=0,
+        test_var1='will_be_overwritten',
+        test_var2='will_be_overwritten',
+        test_var3='unique to config'
+    )
+    kwarg_str = 'proof that we can pass plugins kwargs'
+    config.include(PluginVarSource, plugin_kwarg=kwarg_str)
+    assert config.data['test_var1'] == 'from plugin #1'
+    assert config.data['test_var2'] == 'from plugin #2'
+    assert config.data['test_var3'] == 'unique to config'
+    assert config.data['plugin_kwarg'] == kwarg_str

byoconfig-0.0.1/tests/test_sources_base.py

@@ -0,0 +1,96 @@
+
+import pytest
+
+from fixtures.fixture_source_classes import NameSource
+from byo_config.error import BYOConfigError
+
+
+def test_base_source():
+    source = NameSource('test')
+    assert source.data == {'name': 'test', 'should_appear': 'should_appear'}
+    assert source.var_source_name == 'NameSource'
+    assert source.precedence == 1
+    assert str(source) == 'NameSource: NameSource [1]'
+    assert repr(source) == 'NameSource: NameSource [1]'
+    source_keys = [k for k in source.data.keys()]
+    assert 'precedence' not in source_keys
+    assert 'var_source_name' not in source_keys
+    assert 'metadata' not in source_keys
+    assert '_should_not_appear' not in source_keys
+    assert 'should_appear' in source_keys
+
+
+def test_precedence_and_add():
+    source_a = NameSource('a', "source_a", 1)
+    source_b = NameSource('b', "source_b", 2)
+    source_c = NameSource('c', "source_c", 1)
+    source_d = NameSource('d', "source_d", 2)
+
+    # Test __add__ method
+    source_a = source_a + source_b
+    assert source_a.data == {'name': 'b', 'should_appear': 'should_appear'}
+
+    # Test all other magic methods that use precedence
+    assert int(source_a) == 1
+    assert source_a < source_b
+    assert source_a <= source_b
+    assert source_a <= source_c
+    assert source_b > source_a
+    assert source_b >= source_a
+    assert source_b >= source_d
+    assert source_a != source_b
+    assert source_a == source_c
+
+    with pytest.raises(BYOConfigError) as exec_info_precedence:
+        source_a += source_c
+    assert "as they have the same precedence." in str(exec_info_precedence.value)
+
+    source_c.precedence = None
+    with pytest.raises(BYOConfigError) as exec_info_no_precedence:
+        source_a += source_c
+    assert "as one or both instances have no precedence value." in str(exec_info_no_precedence.value)
+
+    # Test that private attributes are not copied over
+    source_b._should_not_appear = "shouldn't be copied to other source"
+    source_a += source_b
+    assert source_a.data == {'name': 'b', 'should_appear': 'should_appear'}
+    assert source_a._should_not_appear != source_b._should_not_appear
+
+
+def test_name_conflict():
+    source_a = NameSource('a', "source_a", 1)
+    source_b = NameSource('b', "source_a", 2)
+    with pytest.raises(BYOConfigError) as exec_info_name:
+        source_a += source_b
+    assert "as they share the same name." in str(exec_info_name.value)
+
+
+def test_set_data():
+    source_a = NameSource('a', "source_a", 1)
+    source_a.data = {'name': 'b'}
+    assert source_a.data == {'name': 'b', 'should_appear': 'should_appear'}
+
+    # Source should be unchanged if data is set to None
+    source_a.data = None
+    assert source_a.data == {'name': 'b', 'should_appear': 'should_appear'}
+
+    # Source should be unchanged if data is set to an empty dict
+    source_a.data = {}
+    assert source_a.data == {'name': 'b', 'should_appear': 'should_appear'}
+
+    # Test clear_data method with no args
+    source_a.clear_data()
+    assert source_a.data == {}
+
+    # Test clear_data method with args
+    source_a.data = {'name': 'b', 'age': 30}
+    source_a.clear_data('name', 'should_appear')
+    assert source_a.data == {'age': 30}
+
+    # Test clear_data method with non-hashable args
+    with pytest.raises(BYOConfigError) as exec_info:
+        source_a.clear_data(['name'])
+    assert "not hashable types." in str(exec_info.value)
+
+
+

byoconfig-0.0.1/tests/test_sources_env.py

@@ -0,0 +1,62 @@
+import platform
+from os import environ
+
+import pytest
+
+from byo_config.error import BYOConfigError
+
+from fixtures.fixture_source_classes import GenericEnvSource
+
+
+def test_error_modes():
+    with pytest.raises(BYOConfigError) as exec_info_error:
+        GenericEnvSource(111)
+    assert "env_prefix must be a string" in str(exec_info_error.value)
+
+    with pytest.raises(BYOConfigError) as exec_info_error:
+        GenericEnvSource("illegal prefix")
+    assert "env_prefix must be a valid environment variable name" in str(exec_info_error.value)
+
+
+def load_env():
+    environ.update({
+        "BYO_CONFIG_TEST_VAR1": "value1",
+        "BYO_CONFIG_TEST_VAR2": "value2",
+        "BYO_CONFIG_TEST_var3": "value3", # The case should be ignored on windows, converted to uppercase
+    })
+
+
+def test_load_env():
+
+    prefix = "BYO_CONFIG_TEST_"
+    load_env()
+    env_source_1 = GenericEnvSource(prefix)
+    # Test that it accepts either _ or no _ at the end of the prefix
+    env_source_2 = GenericEnvSource(prefix[:-1])
+    env_data = {
+        "VAR1": "value1",
+        "VAR2": "value2",
+        "var3": "value3",
+    }
+    # Handle windows env var case insensitivity
+    if platform.system() == "Windows":
+        del env_data["var3"]
+        env_data["VAR3"] = "value3"
+
+    assert env_source_1.data == env_data
+    assert env_source_2.data == env_data
+
+    # Use the wildcard to load all environment variables
+    env_source_3 = GenericEnvSource("*")
+    # Due to slight difference between the two dictionaries, we will compare a subset of values
+    assert env_source_3.data['COLUMNS'] == environ.get('COLUMNS')
+    if platform.system() == "Windows":
+        assert env_source_3.data['HOMEDRIVE'] == environ.get('HOMEDRIVE')
+        assert env_source_3.data['HOMEPATH'] == environ.get('HOMEPATH')
+    else:
+        assert env_source_3.data['HOME'] == environ.get('HOME')
+        assert env_source_3.data['USER'] == environ.get('USER')
+
+    # Test if using None as the prefix does not result in errors
+    env_source_4 = GenericEnvSource(None)
+    assert env_source_4.data == {}

byoconfig-0.0.1/tests/test_sources_file.py

@@ -0,0 +1,112 @@
+import pytest
+
+from byo_config.error import BYOConfigError
+
+from fixtures.fixture_source_classes import GenericFileSource
+from fixtures.pathing import example_configs, fixtures_dir, output_dir
+
+
+def test_error_modes():
+    # Test that the error modes are working as expected
+    with pytest.raises(FileNotFoundError) as exec_info_file_not_found:
+        GenericFileSource('non_existent_file', forced_file_type=None)
+    assert "Config file non_existent_file does not exist" in str(exec_info_file_not_found.value)
+
+    python_file = str(fixtures_dir / 'fixture_source_classes.py')
+    with pytest.raises(BYOConfigError) as exec_info_error:
+        GenericFileSource(python_file, forced_file_type=None)
+    assert "does not posses one of the allowed file extensions" in str(exec_info_error.value)
+
+    invalid_json = str(fixtures_dir / 'invalid.json')
+    with pytest.raises(BYOConfigError) as exec_info_error:
+        GenericFileSource(invalid_json, forced_file_type=None)
+    assert "Expecting property name enclosed in double quotes " in str(exec_info_error.value)
+
+    invalid_toml = str(fixtures_dir / 'invalid.toml')
+    with pytest.raises(BYOConfigError) as exec_info_error:
+        GenericFileSource(invalid_toml, forced_file_type=None)
+    assert "Invalid group name '{this is invalid}'." in str(exec_info_error.value)
+
+    invalid_yaml = str(fixtures_dir / 'invalid.yaml')
+    with pytest.raises(BYOConfigError) as exec_info_error:
+        GenericFileSource(invalid_yaml, forced_file_type=None)
+    # todo: figure out how to get yaml error message
+
+
+def test_load_file_modes():
+    example_dict = {
+        "parent": {
+            "some": "thing",
+            "child": {
+                "other": "thing"
+            }
+        }
+    }
+
+    yaml_file = str(example_configs / 'same_as.yaml')
+    yaml_source = GenericFileSource(yaml_file)
+    assert yaml_source.data == example_dict
+
+    toml_file = str(example_configs / 'same_as.toml')
+    toml_source = GenericFileSource(toml_file)
+    assert toml_source.data == example_dict
+
+    json_file = str(example_configs / 'same_as.json')
+    json_source = GenericFileSource(json_file)
+    assert json_source.data == example_dict
+
+
+def compare_file_contents(file1, file2):
+    with open(file1, 'r') as f1:
+        with open(file2, 'r') as f2:
+            return f1.read() == f2.read()
+
+
+def test_dump_file_modes():
+    example_dict = {
+        "parent": {
+            "some": "thing",
+            "child": {
+                "other": "thing"
+            }
+        }
+    }
+    # ensure that output_dir exists
+    output_dir.mkdir(exist_ok=True)
+    yaml_file = str(example_configs / 'same_as.yaml')
+    yaml_dump = str(output_dir / 'dumped.yaml')
+    yaml_source = GenericFileSource(yaml_file)
+    yaml_source.dump(yaml_dump)
+    assert compare_file_contents(yaml_file, yaml_dump)
+
+    toml_file = str(example_configs / 'same_as.toml')
+    toml_dump = str(output_dir / 'dumped.toml')
+    toml_source = GenericFileSource(toml_file)
+    toml_source.dump(toml_dump)
+    assert compare_file_contents(toml_file, toml_dump)
+
+    json_file = str(example_configs / 'same_as.json')
+    json_dump = str(output_dir / 'dumped.json')
+    json_source = GenericFileSource(json_file)
+    json_source.dump(json_dump)
+    assert compare_file_contents(json_file, json_dump)
+
+
+def test_forced_file_type():
+    yaml_file = str(fixtures_dir / 'this_is_yaml')
+    yaml_source = GenericFileSource(yaml_file, forced_file_type='YAML')
+    assert yaml_source.data == {
+        'this': 'is yaml'
+    }
+
+    toml_file = str(fixtures_dir / 'this_is_toml')
+    toml_source = GenericFileSource(toml_file, forced_file_type='TOML')
+    assert toml_source.data == {
+        'parent': {'this': 'is toml'}
+    }
+
+    json_file = str(fixtures_dir / 'this_is_json')
+    json_source = GenericFileSource(json_file, forced_file_type='JSON')
+    assert json_source.data == {
+        'this': 'is json'
+    }