Add TOMLConfig and MemoryConfig classes

Author: Antoine

README.md

@@ -5,10 +5,11 @@ a collection of python classes and functions that I use in my projects
 
 ### `config.py`
 
-A class to read and write configuration files, currently only in json format.  
+A class to read and write configuration files, in json or toml format.  
+Also support memory-only configuration (do not persist to file).  
 Support nested dictionaries and lists, as well as combined keys (e.g. `a.b.c`).  
 Also support referencing other keys :
-```properties
+```python
 a = "hello"
 b = "${a} world"
 ```

config/config/__init__.py

@@ -1 +1 @@
-from .config import BaseConfig, JSONConfig
+from .config import MemoryConfig, JSONConfig, TOMLConfig

config/config/config.py

@@ -4,11 +4,12 @@
 Configuration management module.
 """
 
-from json import loads, dump, JSONDecodeError
+from json import loads, dumps
 from abc import ABC, abstractmethod
 from datetime import datetime
 import re
 import os
+import tomlkit
 from typing import Any, Dict
 
 try: # use gamuLogger if available # pragma: no cover
@@ -17,40 +18,21 @@
     def _trace(msg: str) -> None:
         Logger.trace(msg)
 except ImportError: # pragma: no cover
-    def _trace(_: str) -> None:
-        pass
+    def _trace(msg: str) -> None:
+        print(msg)
 
 
 
-class BaseConfig(ABC):
+class BaseConfig:
     """
     Base class for configuration management.
-    This class provides methods to load, save, and manage configuration settings.
-    It is designed to be subclassed for specific configuration formats (e.g., JSON, YAML).
+    This class provides methods to manage configuration settings.
+    Can be subclassed for specific configuration formats (e.g., JSON, YAML).
     """
     RE_REFERENCE = re.compile(r'\$\{([a-zA-Z0-9_.]+)\}')
 
     def __init__(self):
         self._config : Dict[str, Any] = {}
-        self._load()
-
-    @abstractmethod
-    def _load(self) -> 'BaseConfig':
-        """
-        Load configuration
-        """
-
-    @abstractmethod
-    def _save(self) -> 'BaseConfig':
-        """
-        Save configuration
-        """
-
-    @abstractmethod
-    def _reload(self) -> 'BaseConfig':
-        """
-        Reload configuration
-        """
 
     def get(self, key: str, /, default: Any = None, set_if_not_found: bool = False) -> str | int | float | bool:
         """
@@ -61,7 +43,6 @@ def get(self, key: str, /, default: Any = None, set_if_not_found: bool = False)
         :return: Configuration value.
         """
         _trace(f"Getting config value for key: {key}")
-        self._reload()
         key_tokens = key.split('.')
         config = self._config
         for token in key_tokens:
@@ -92,7 +73,6 @@ def set(self, key: str, value : Any) -> 'BaseConfig':
         :param value: Configuration value.
         """
         _trace(f"Setting config value for key: {key} to {value}")
-        self._reload()
         key_tokens = key.split('.')
         config = self._config
         for token in key_tokens[:-1]:
@@ -103,7 +83,6 @@ def set(self, key: str, value : Any) -> 'BaseConfig':
             config[key_tokens[-1]] = value
         except TypeError:
             raise TypeError(f"Cannot set value for key '{key}' because key is already a non-dict type.") from None
-        self._save()
         return self
 
     def remove(self, key: str) -> 'BaseConfig':
@@ -113,7 +92,6 @@ def remove(self, key: str) -> 'BaseConfig':
         :param key: Configuration key.
         """
         _trace(f"Removing config key: {key}")
-        self._reload()
         key_tokens = key.split('.')
         config = self._config
         for token in key_tokens[:-1]:
@@ -129,37 +107,52 @@ def remove(self, key: str) -> 'BaseConfig':
             raise KeyError(f"Key '{key}' not found in configuration.")
         return self
 
+    def __str__(self) -> str:
+        """
+        String representation of the configuration.
+        """
+        return str(self._config)
 
-class JSONConfig(BaseConfig):
+    def __repr__(self) -> str:
+        """
+        String representation of the configuration.
+        """
+        return f"{self.__class__.__name__}({self._config})"
+
+class FileConfig(BaseConfig, ABC):
     """
-    JSON configuration management class.
-    This class provides methods to load, save, and manage configuration settings in JSON format.
+    File configuration management class.
+
+    Must be subclassed for specific file formats (e.g., JSON, TOML) that implement `_to_string` and `_from_string`.
     """
     def __init__(self, file_path: str):
         self.file_path = file_path
         self._last_modified = datetime.now()
         super().__init__()
+        self._load()
+
+    def __init_empty(self) -> 'FileConfig':
+        self._config = {}
+        self._save()
+        return self
 
-    def _load(self) -> 'JSONConfig':
+    def _load(self) -> 'FileConfig':
         """
-        Load configuration from a JSON file.
+        Load configuration from a config file.
+        the _from_string method must be implemented in subclasses.
         """
         _trace(f"Loading configuration from {self.file_path}")
         if not os.path.exists(self.file_path):
-            self._config = {}
-            self._save()
-            return self
+            return self.__init_empty()
         with open(self.file_path, 'r', encoding="utf-8") as file:
             content = file.read()
             if content.strip() == "":
                 _trace(f"Configuration file {self.file_path} is empty, creating empty config")
-                self._config = {}
-                self._save()
-                return self
-            self._config = loads(content)
+                return self.__init_empty()
+            self._from_string(content)
         return self
 
-    def _reload(self) -> 'JSONConfig':
+    def _reload(self) -> 'FileConfig':
         """
         Reload configuration from a JSON file if the modification time has changed.
         """
@@ -169,20 +162,138 @@ def _reload(self) -> 'JSONConfig':
             return self
         file_modified_time = os.path.getmtime(self.file_path) #when the file was last modified
         config_modified_time = self._last_modified.timestamp() #when the config was last modified (this object)
-        if self._last_modified is None or file_modified_time > config_modified_time:
+        if file_modified_time > config_modified_time:
             _trace(f"Reloading configuration from {self.file_path} due to modification time change")
             self._load()
             self._last_modified = datetime.fromtimestamp(file_modified_time)
         else:
             _trace(f"Configuration file {self.file_path} has not changed since last load")
         return self
 
-    def _save(self) -> 'JSONConfig':
+    def _save(self) -> 'FileConfig':
         """
         Save configuration to a JSON file.
         """
         _trace(f"Saving configuration to {self.file_path}")
         with open(self.file_path, 'w', encoding="utf-8") as file:
-            dump(self._config, file, indent=4)
+            file.write(self._to_string())
         self._last_modified = datetime.now()
         return self
+
+    def get(self, key: str, /, default: Any = None, set_if_not_found: bool = False) -> str | int | float | bool:
+        """
+        Get the value of a configuration key.
+        
+        :param key: Configuration key.
+        :param default: Default value if the key does not exist.
+        :return: Configuration value.
+        """
+        self._reload()
+        return super().get(key, default, set_if_not_found)
+
+    def set(self, key: str, value: Any) -> 'FileConfig':
+        """
+        Set the value of a configuration key.
+        
+        :param key: Configuration key.
+        :param value: Configuration value.
+        """
+        self._reload()
+        super().set(key, value)
+        self._save()
+        return self
+
+    def remove(self, key: str) -> 'FileConfig':
+        """
+        Remove a configuration key.
+        
+        :param key: Configuration key.
+        """
+        self._reload()
+        super().remove(key)
+        self._save()
+        return self
+
+    @abstractmethod
+    def _to_string(self) -> str:
+        """
+        String representation of the configuration.
+        """
+
+    @abstractmethod
+    def _from_string(self, config_string: str) -> None:
+        """
+        Create a configuration object from a string.
+        
+        :param config_string: Configuration string.
+        :return: Configuration object.
+        """
+
+class JSONConfig(FileConfig):
+    """
+    JSON configuration management class.
+    This class provides methods to load, save, and manage configuration settings in JSON format.
+    """
+
+    def _to_string(self) -> str:
+        """
+        String representation of the configuration in JSON format.
+        """
+        return dumps(self._config, indent=4)
+
+    def _from_string(self, config_string: str) -> None:
+        """
+        Create a configuration object from a JSON string.
+        
+        :param config_string: Configuration string.
+        :return: Configuration object.
+        """
+        self._config = loads(config_string)
+        if not isinstance(self._config, dict):
+            raise ValueError("Invalid JSON format: expected a dictionary.")
+
+class TOMLConfig(FileConfig):
+    """
+    TOML configuration management class.
+    This class provides methods to load, save, and manage configuration settings in TOML format.
+    """
+
+    def _to_string(self) -> str:
+        """
+        String representation of the configuration in TOML format.
+        """
+        return tomlkit.dumps(self._config)
+
+    def _from_string(self, config_string: str) -> None:
+        """
+        Create a configuration object from a TOML string.
+        
+        :param config_string: Configuration string.
+        :return: Configuration object.
+        """
+        self._config = tomlkit.loads(config_string)
+
+class MemoryConfig(BaseConfig):
+    """
+    In-memory configuration management class.
+    This class provides methods to load, save, and manage configuration settings in memory.
+    Does not persist to a file.
+    """
+    def __init__(self, initial: Dict[str, Any] = None):
+        super().__init__()
+        if initial is not None:
+            self._config = initial
+
+
+def get_config(file_path: str) -> FileConfig:
+    """
+    Get a configuration object based on the file extension.
+    
+    :param file_path: Path to the configuration file.
+    :return: Configuration object.
+    """
+    if file_path.lower().endswith('.json'):
+        return JSONConfig(file_path)
+    if file_path.lower().endswith('.toml'):
+        return TOMLConfig(file_path)
+    raise ValueError(f"Unsupported configuration file format: {file_path}")

config/pyproject.toml

@@ -10,6 +10,9 @@ authors = [
     { name = "Antoine BUIREY", email = "antoine.buirey@gmail.com" }
 ]
 requires-python = ">=3.10"
+dependencies = [
+    "tomlkit==0.13.2"
+]
 
 [tool.setuptools.packages.find]
 include = [

config/tests/file_tests.py

@@ -0,0 +1,56 @@
+import os
+import pytest
+from unittest.mock import patch, mock_open
+import builtins
+import tempfile
+
+
+# raise a ImportError for "import gamuLogger"
+base_import = builtins.__import__
+def mock_import(name, globals=None, locals=None, fromlist=(), level=0):
+    if name == "gamuLogger":
+        raise ImportError("Mocked ImportError for gamuLogger")
+    return base_import(name, globals, locals, fromlist, level)
+builtins.__import__ = mock_import
+
+from config.config.config import FileConfig
+
+class DummyFileConfig(FileConfig):
+    """
+    Dummy implementation of FileConfig for testing purposes.
+    """
+    def _to_string(self) -> str:
+        return str(self._config)
+
+    def _from_string(self, config_string: str) -> None:
+        self._config = eval(config_string)
+
+
+class TestFileConfig:
+    @pytest.fixture
+    def file_config(self):
+        with tempfile.NamedTemporaryFile(delete=False, mode="w+") as temp_file:
+            temp_file.write('{"key": "value"}')
+            temp_file_path = temp_file.name
+        config = DummyFileConfig(temp_file_path)
+        yield config
+        os.remove(temp_file_path)
+
+    def test_get(self, file_config : DummyFileConfig):
+        assert file_config.get('key') == 'value'
+        assert file_config.get('non_existent_key', default='default_value') == 'default_value'
+
+    def test_set(self, file_config : DummyFileConfig):
+        file_config.set('new_key', 'new_value')
+        assert file_config.get('new_key') == 'new_value'
+
+    def test_remove(self, file_config : DummyFileConfig):
+        file_config.set('key_to_remove', 'value')
+        file_config.remove('key_to_remove')
+        assert file_config.get('key_to_remove', default='default_value') == 'default_value'
+
+    def test_str(self, file_config : DummyFileConfig):
+        assert str(file_config) == "{'key': 'value'}"
+        
+    def test_repr(self, file_config : DummyFileConfig):
+        assert repr(file_config) == f"DummyFileConfig({file_config._config})"