dynamic-config-loader 2.1.0__tar.gz → 2.2.0__tar.gz

{dynamic_config_loader-2.1.0/src/dynamic_config_loader.egg-info → dynamic_config_loader-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.1.0
+Version: 2.2.0
 Summary: An enterprise-grade configuration orchestration engine designed to ingest, cascade, and deeply merge multiple configuration file layers.
 Author-email: Avinash Kumar <halfhiddencode@gmail.com>
 License: 

{dynamic_config_loader-2.1.0 → dynamic_config_loader-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dynamic-config-loader"
-version = "2.1.0"
+version = "2.2.0"
 description = "An enterprise-grade configuration orchestration engine designed to ingest, cascade, and deeply merge multiple configuration file layers."
 readme = "README.md"
 requires-python = ">=3.8"

{dynamic_config_loader-2.1.0 → dynamic_config_loader-2.2.0}/src/dynamic_config_loader/loader.py

@@ -72,6 +72,13 @@ class DynamicConfigLoader:
                 "======================================================================="
             )
 
+        # Resolve the allowed format strategy class based on the baseline configuration file extension
+        allowed_strategy_cls = None
+        if self.default_path:
+            base_strategy = factory.get_strategy(self.default_path.suffix)
+            if base_strategy:
+                allowed_strategy_cls = type(base_strategy)
+
         # Pipeline Phase 1: Assess and ingest baseline layer properties
         if self.default_path and self.default_path.exists():
             # Dynamically look up the decoupled format strategy class using the extension suffix
@@ -113,6 +120,12 @@ class DynamicConfigLoader:
                         if file_path.is_file():
                             strategy = factory.get_strategy(file_path.suffix)
                             if strategy:
+                                if allowed_strategy_cls and not isinstance(strategy, allowed_strategy_cls):
+                                    logger.warning(
+                                        f"Skipping override file '{file_path.name}' due to format mismatch "
+                                        f"with baseline strategy '{allowed_strategy_cls.__name__}'."
+                                    )
+                                    continue
                                 try:
                                     logger.info(f"Processing override layer discovery file: {file_path.name}")
                                     extra_data = strategy.parse(file_path)
@@ -129,6 +142,12 @@ class DynamicConfigLoader:
                 elif current_path.is_file():
                     strategy = factory.get_strategy(current_path.suffix)
                     if strategy:
+                        if allowed_strategy_cls and not isinstance(strategy, allowed_strategy_cls):
+                            logger.warning(
+                                f"Skipping direct override file asset '{current_path.name}' due to format mismatch "
+                                f"with baseline strategy '{allowed_strategy_cls.__name__}'."
+                            )
+                            continue
                         try:
                             logger.info(f"Processing direct override file asset: {current_path.name}")
                             extra_data = strategy.parse(current_path)

{dynamic_config_loader-2.1.0 → dynamic_config_loader-2.2.0}/src/dynamic_config_loader/strategies/__init__.py

@@ -15,6 +15,7 @@ from dynamic_config_loader.strategies.base_strategy import BaseStrategy
 
 # Import the strategy worker class from the underlying yaml package
 from dynamic_config_loader.strategies.yaml import YamlStrategy
+from dynamic_config_loader.strategies.json import JsonStrategy
 
 
 class StrategyFactory:
@@ -26,10 +27,11 @@ class StrategyFactory:
         """
         Initializes the factory and registers file extension routes to concrete strategy objects.
         """
-        # Register extension routes straight to your isolated yaml folder class
+        # Register extension routes straight to your isolated strategy classes
         self._strategies: Dict[str, BaseStrategy] = {
             ".yaml": YamlStrategy(),
-            ".yml": YamlStrategy()
+            ".yml": YamlStrategy(),
+            ".json": JsonStrategy(),
         }
 
     def get_strategy(self, extension: str) -> Optional[BaseStrategy]:

dynamic_config_loader-2.2.0/src/dynamic_config_loader/strategies/json/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+JSON Strategy Package Initializer.
+
+Exposes the concrete JsonStrategy engine implementation.
+"""
+
+from pathlib import Path
+from typing import Any, Dict
+from dynamic_config_loader.strategies.base_strategy import BaseStrategy
+from dynamic_config_loader.strategies.json.parser import parse_json_file
+from dynamic_config_loader.strategies.json.merger import execute_json_deep_merge
+
+
+class JsonStrategy(BaseStrategy):
+    """
+    Concrete Strategy implementation managing the processing life cycle of JSON configurations.
+    """
+
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        return parse_json_file(file_path)
+
+    def merge(
+        self,
+        base_dict: Dict[str, Any],
+        update_dict: Dict[str, Any],
+        path: str = "",
+        mask_secrets: bool = True,
+    ) -> None:
+        execute_json_deep_merge(base_dict, update_dict, path=path, mask_secrets=mask_secrets)

dynamic_config_loader-2.2.0/src/dynamic_config_loader/strategies/json/merger.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+JSON Merging Strategy Module.
+
+Provides recursive tree-merging algorithms engineered to blend cascading JSON layers.
+"""
+
+import logging
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def execute_json_deep_merge(
+    base_dict: Dict[str, Any],
+    update_dict: Dict[str, Any],
+    path: str = "",
+    mask_secrets: bool = True,
+) -> None:
+    """
+    Recursively deep-merges update_dict into base_dict in-place.
+    """
+    for key, value in update_dict.items():
+        current_path = f"{path}.{key}" if path else key
+
+        # Case A: Both values are dictionaries -> recurse
+        if key in base_dict and isinstance(base_dict[key], dict) and isinstance(value, dict):
+            logger.debug(f"Deep merging nested JSON structure at path: {current_path}")
+            execute_json_deep_merge(base_dict[key], value, path=current_path, mask_secrets=mask_secrets)
+
+        # Case B: Structural conflict or key exists
+        elif key in base_dict:
+            if isinstance(base_dict[key], dict) or isinstance(value, dict):
+                logger.warning(
+                    f"Type mismatch conflict detected at path '{current_path}'. "
+                    f"Overwriting base JSON structural type ({type(base_dict[key]).__name__}) "
+                    f"with incoming type ({type(value).__name__})."
+                )
+                base_dict[key] = value
+            else:
+                if base_dict[key] != value:
+                    if logger.isEnabledFor(logging.DEBUG):
+                        if not mask_secrets:
+                            logger.debug(f"Updating JSON path '{current_path}': {repr(base_dict[key])} -> {repr(value)}")
+                        else:
+                            logger.debug(f"Updating JSON path '{current_path}': [REDACTED] -> [REDACTED]")
+                    else:
+                        logger.info(f"Updating configuration attribute path: {current_path} [Value Redacted]")
+                    base_dict[key] = value
+        # Case C: New key
+        else:
+            if logger.isEnabledFor(logging.DEBUG):
+                if not mask_secrets:
+                    logger.debug(f"Adding new JSON key at path '{current_path}': {repr(value)}")
+                else:
+                    logger.debug(f"Adding new JSON key at path '{current_path}': [REDACTED]")
+            else:
+                logger.info(f"Adding new configuration attribute path: {current_path} [Value Redacted]")
+            base_dict[key] = value

dynamic_config_loader-2.2.0/src/dynamic_config_loader/strategies/json/parser.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+JSON Parsing Strategy Module.
+
+Provides isolated, low-level file stream ingestion utilities optimized
+for handling standard JSON configuration assets.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def parse_json_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Reads a JSON configuration file asset from disk and returns a dictionary mapping.
+    """
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            if data is None:
+                logger.info(f"Target JSON file context is empty or unassigned: {file_path.name}")
+                return {}
+            if isinstance(data, dict):
+                return data
+            logger.warning(
+                f"Invalid structural layout detected inside file: {file_path.name}. "
+                f"Expected key-value schema tree map, but received root type: {type(data).__name__}."
+            )
+            return {}
+    except (json.JSONDecodeError, IOError, PermissionError) as e:
+        logger.exception(f"Failed to read or parse JSON file: {file_path.name}", exc_info=e)
+        return {}

{dynamic_config_loader-2.1.0 → dynamic_config_loader-2.2.0/src/dynamic_config_loader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.1.0
+Version: 2.2.0
 Summary: An enterprise-grade configuration orchestration engine designed to ingest, cascade, and deeply merge multiple configuration file layers.
 Author-email: Avinash Kumar <halfhiddencode@gmail.com>
 License: 

{dynamic_config_loader-2.1.0 → dynamic_config_loader-2.2.0}/src/dynamic_config_loader.egg-info/SOURCES.txt

@@ -13,11 +13,15 @@ src/dynamic_config_loader.egg-info/requires.txt
 src/dynamic_config_loader.egg-info/top_level.txt
 src/dynamic_config_loader/strategies/__init__.py
 src/dynamic_config_loader/strategies/base_strategy.py
+src/dynamic_config_loader/strategies/json/__init__.py
+src/dynamic_config_loader/strategies/json/merger.py
+src/dynamic_config_loader/strategies/json/parser.py
 src/dynamic_config_loader/strategies/yaml/__init__.py
 src/dynamic_config_loader/strategies/yaml/merger.py
 src/dynamic_config_loader/strategies/yaml/parser.py
 tests/test_deep_merge.py
 tests/test_env_injection.py
 tests/test_factory.py
+tests/test_json_strategy.py
 tests/test_loader.py
 tests/test_logging_safety.py

{dynamic_config_loader-2.1.0 → dynamic_config_loader-2.2.0}/tests/test_factory.py

@@ -3,6 +3,7 @@
 import unittest
 from dynamic_config_loader.strategies import factory
 from dynamic_config_loader.strategies.yaml import YamlStrategy
+from dynamic_config_loader.strategies.json import JsonStrategy
 
 
 class TestStrategyFactory(unittest.TestCase):
@@ -14,9 +15,11 @@ class TestStrategyFactory(unittest.TestCase):
         # Test standard extensions
         strategy_yaml = factory.get_strategy(".yaml")
         strategy_yml = factory.get_strategy(".yml")
+        strategy_json = factory.get_strategy(".json")
 
         self.assertIsInstance(strategy_yaml, YamlStrategy)
         self.assertIsInstance(strategy_yml, YamlStrategy)
+        self.assertIsInstance(strategy_json, JsonStrategy)
 
     def test_factory_case_insensitivity(self):
         """
@@ -24,15 +27,16 @@ class TestStrategyFactory(unittest.TestCase):
         """
         strategy_mixed = factory.get_strategy(".YaMl")
         strategy_upper = factory.get_strategy(".YML")
+        strategy_json_upper = factory.get_strategy(".JSON")
 
         self.assertIsInstance(strategy_mixed, YamlStrategy)
         self.assertIsInstance(strategy_upper, YamlStrategy)
+        self.assertIsInstance(strategy_json_upper, JsonStrategy)
 
     def test_factory_unsupported_extensions(self):
         """
         Verifies that StrategyFactory returns None for unregistered extensions.
         """
-        self.assertIsNone(factory.get_strategy(".json"))
         self.assertIsNone(factory.get_strategy(".xml"))
         self.assertIsNone(factory.get_strategy(".ini"))
 

dynamic_config_loader-2.2.0/tests/test_json_strategy.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import os
+import unittest
+from pathlib import Path
+from dynamic_config_loader.loader import DynamicConfigLoader
+from dynamic_config_loader.strategies.json.parser import parse_json_file
+from dynamic_config_loader.strategies.json.merger import execute_json_deep_merge
+
+
+class TestJsonStrategy(unittest.TestCase):
+
+    def setUp(self):
+        self.TEST_DIR = Path(__file__).parent
+        self.base_file = self.TEST_DIR / "test_configs" / "base_config.json"
+        self.overrides_dir = self.TEST_DIR / "test_configs" / "overrides"
+
+        # Clear env variables
+        if "PYTHON_ADDITIONAL_CONFIG" in os.environ:
+            del os.environ["PYTHON_ADDITIONAL_CONFIG"]
+        if "ENABLE_UNSAFE_LOGGING" in os.environ:
+            del os.environ["ENABLE_UNSAFE_LOGGING"]
+
+    def tearDown(self):
+        if "PYTHON_ADDITIONAL_CONFIG" in os.environ:
+            del os.environ["PYTHON_ADDITIONAL_CONFIG"]
+        if "ENABLE_UNSAFE_LOGGING" in os.environ:
+            del os.environ["ENABLE_UNSAFE_LOGGING"]
+
+    def test_json_parsing(self):
+        """
+        Verifies that parse_json_file correctly parses JSON files into dictionaries.
+        """
+        data = parse_json_file(self.base_file)
+        self.assertEqual(data["app_name"], "Test JSON Gateway")
+        self.assertEqual(data["database"]["port"], 5432)
+
+    def test_json_deep_merging(self):
+        """
+        Verifies recursive deep merges and type mismatch resolution for JSON structures.
+        """
+        base = {
+            "debug": False,
+            "database": {
+                "host": "localhost",
+                "settings": {"pool": 10}
+            }
+        }
+        update = {
+            "debug": True,
+            "database": {
+                "settings": {"pool": 20, "timeout": 30}
+            }
+        }
+
+        execute_json_deep_merge(base, update)
+
+        self.assertTrue(base["debug"])
+        self.assertEqual(base["database"]["host"], "localhost")
+        self.assertEqual(base["database"]["settings"]["pool"], 20)
+        self.assertEqual(base["database"]["settings"]["timeout"], 30)
+
+    def test_json_loader_integration(self):
+        """
+        Verifies that DynamicConfigLoader correctly orchestrates baseline JSON and directory overrides JSON.
+        """
+        # Set overrides path in env
+        os.environ["PYTHON_ADDITIONAL_CONFIG"] = str(self.overrides_dir)
+
+        loader = DynamicConfigLoader(default_config_path=str(self.base_file))
+        result = loader.load()
+
+        # baseline JSON: Test JSON Gateway, overrides folder has 01_dev_patch.json overriding database host
+        self.assertEqual(result["app_name"], "Test JSON Gateway")
+        self.assertTrue(result["debug_mode"])
+        self.assertEqual(result["database"]["host"], "json-dev-cluster.local")
+        self.assertEqual(result["database"]["port"], 5432)
+
+    def test_json_log_masking(self):
+        """
+        Verifies that logging of updates/additions for JSON conforms to mask_secrets checks.
+        """
+        base = {"db_pass": "old_secret"}
+        update = {"db_pass": "new_secret"}
+
+        # Safe logs (default mask_secrets=True)
+        with self.assertLogs("dynamic_config_loader", level=logging.DEBUG) as log_capture:
+            execute_json_deep_merge(base, update, mask_secrets=True)
+
+        log_messages = "\n".join(log_capture.output)
+        self.assertIn("[REDACTED]", log_messages)
+        self.assertNotIn("new_secret", log_messages)
+
+        # Reset base to ensure the second execution performs an update and triggers log outputs
+        base = {"db_pass": "old_secret"}
+
+        # Unsafe logs (mask_secrets=False via ENABLE_UNSAFE_LOGGING setting)
+        os.environ["ENABLE_UNSAFE_LOGGING"] = "true"
+        loader_unsafe = DynamicConfigLoader(default_config_path=str(self.base_file))
+        loader_unsafe.load()  # Resolves self.mask_secrets to False
+
+        with self.assertLogs("dynamic_config_loader", level=logging.DEBUG) as log_capture_unsafe:
+            execute_json_deep_merge(base, update, mask_secrets=loader_unsafe.mask_secrets)
+
+        log_messages_unsafe = "\n".join(log_capture_unsafe.output)
+        self.assertIn("new_secret", log_messages_unsafe)
+        self.assertNotIn("[REDACTED]", log_messages_unsafe)
+
+
+if __name__ == "__main__":
+    unittest.main()