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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.2.0
+Version: 2.4.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: 
@@ -210,7 +210,7 @@ Project-URL: Repository, https://gitlab.com/halfhiddencode/python-dynamic-config
 Project-URL: Issues, https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/issues
 Project-URL: Documentation, https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/tree/main/docs
 Project-URL: Changelog, https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CHANGELOG.md
-Keywords: config,configuration,dynamic-loader,cascading-config,deep-merge,strategy-pattern,yaml,json,devops
+Keywords: config,configuration,dynamic-loader,cascading-config,deep-merge,strategy-pattern,yaml,json,xml,toml,ini,conf,devops
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
@@ -232,12 +232,22 @@ License-File: LICENSE
 License-File: NOTICE
 License-File: AUTHORS
 Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 Dynamic: license-file
 
 # Dynamic Configuration Loader
 
 A lightweight, production-grade, strategy-driven configuration orchestration engine designed to dynamically discover, alphabetically sort, and recursively deep-merge multi-layered configuration files.
 
+## Supported Formats
+
+The orchestration engine natively parses and cascades the following configuration formats:
+* **YAML** (`.yaml`, `.yml`)
+* **JSON** (`.json`)
+* **XML** (`.xml`)
+* **TOML** (`.toml`)
+* **INI / Conf** (`.ini`, `.conf`)
+
 ---
 
 ```text
@@ -308,14 +318,14 @@ The complete enterprise documentation is organized under the Diátaxis framework
 
 | Track | Target Document | Description |
 | :--- | :--- | :--- |
-| **Getting Started** | [Getting Started Tutorial](docs/tutorials/getting_started.md) | Onboarding sequence, repeatable format tracks, and installation via GitLab Package Registry. |
-| **Operations Guide** | [Advanced Ingestion and Path Traversal Guide](docs/guides/user_usage.md) | Path parsing matrix, edge-case refusals, Central Config Manager pattern, and log masking safety details. |
-| **Contributor Guide** | [Format Strategy Contribution Guide](docs/guides/contributor_guide.md) | Abstract base strategy class signatures, factory registration hooks, and copy-pasteable JSON blueprints. |
-| **Technical Reference** | [Core Architecture Reference](docs/reference/architecture.md) | System design architecture, UML mapping, execution pipelines, and logging safety compliance matrices. |
+| **Getting Started** | [Getting Started Tutorial](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/tutorials/getting_started.md) | Onboarding sequence, repeatable format tracks, and installation via GitLab Package Registry. |
+| **Operations Guide** | [Advanced Ingestion and Path Traversal Guide](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/guides/user_usage.md) | Path parsing matrix, edge-case refusals, Central Config Manager pattern, and log masking safety details. |
+| **Contributor Guide** | [Format Strategy Contribution Guide](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/guides/contributor_guide.md) | Abstract base strategy class signatures, factory registration hooks, and copy-pasteable JSON blueprints. |
+| **Technical Reference** | [Core Architecture Reference](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/reference/architecture.md) | System design architecture, UML mapping, execution pipelines, and logging safety compliance matrices. |
 
 ---
 
 ## Repository Ledgers
-* Version History: [CHANGELOG.md](CHANGELOG.md)
-* Security Policy: [SECURITY.md](SECURITY.md)
-* Contribution Protocols: [CONTRIBUTING.md](CONTRIBUTING.md)
+* Version History: [CHANGELOG.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CHANGELOG.md)
+* Security Policy: [SECURITY.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/SECURITY.md)
+* Contribution Protocols: [CONTRIBUTING.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CONTRIBUTING.md)

{dynamic_config_loader-2.2.0 → dynamic_config_loader-2.4.0}/README.md

@@ -2,6 +2,15 @@
 
 A lightweight, production-grade, strategy-driven configuration orchestration engine designed to dynamically discover, alphabetically sort, and recursively deep-merge multi-layered configuration files.
 
+## Supported Formats
+
+The orchestration engine natively parses and cascades the following configuration formats:
+* **YAML** (`.yaml`, `.yml`)
+* **JSON** (`.json`)
+* **XML** (`.xml`)
+* **TOML** (`.toml`)
+* **INI / Conf** (`.ini`, `.conf`)
+
 ---
 
 ```text
@@ -72,14 +81,14 @@ The complete enterprise documentation is organized under the Diátaxis framework
 
 | Track | Target Document | Description |
 | :--- | :--- | :--- |
-| **Getting Started** | [Getting Started Tutorial](docs/tutorials/getting_started.md) | Onboarding sequence, repeatable format tracks, and installation via GitLab Package Registry. |
-| **Operations Guide** | [Advanced Ingestion and Path Traversal Guide](docs/guides/user_usage.md) | Path parsing matrix, edge-case refusals, Central Config Manager pattern, and log masking safety details. |
-| **Contributor Guide** | [Format Strategy Contribution Guide](docs/guides/contributor_guide.md) | Abstract base strategy class signatures, factory registration hooks, and copy-pasteable JSON blueprints. |
-| **Technical Reference** | [Core Architecture Reference](docs/reference/architecture.md) | System design architecture, UML mapping, execution pipelines, and logging safety compliance matrices. |
+| **Getting Started** | [Getting Started Tutorial](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/tutorials/getting_started.md) | Onboarding sequence, repeatable format tracks, and installation via GitLab Package Registry. |
+| **Operations Guide** | [Advanced Ingestion and Path Traversal Guide](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/guides/user_usage.md) | Path parsing matrix, edge-case refusals, Central Config Manager pattern, and log masking safety details. |
+| **Contributor Guide** | [Format Strategy Contribution Guide](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/guides/contributor_guide.md) | Abstract base strategy class signatures, factory registration hooks, and copy-pasteable JSON blueprints. |
+| **Technical Reference** | [Core Architecture Reference](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/reference/architecture.md) | System design architecture, UML mapping, execution pipelines, and logging safety compliance matrices. |
 
 ---
 
 ## Repository Ledgers
-* Version History: [CHANGELOG.md](CHANGELOG.md)
-* Security Policy: [SECURITY.md](SECURITY.md)
-* Contribution Protocols: [CONTRIBUTING.md](CONTRIBUTING.md)
+* Version History: [CHANGELOG.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CHANGELOG.md)
+* Security Policy: [SECURITY.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/SECURITY.md)
+* Contribution Protocols: [CONTRIBUTING.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CONTRIBUTING.md)

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dynamic-config-loader"
-version = "2.2.0"
+version = "2.4.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"
@@ -23,6 +23,10 @@ keywords = [
     "strategy-pattern",
     "yaml",
     "json",
+    "xml",
+    "toml",
+    "ini",
+    "conf",
     "devops"
 ]
 
@@ -46,6 +50,7 @@ classifiers = [
 
 dependencies = [
     "pyyaml>=6.0.1",
+    "tomli>=2.0.1; python_version < '3.11'",
 ]
 
 [project.urls]

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

@@ -16,6 +16,9 @@ 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
+from dynamic_config_loader.strategies.xml import XmlStrategy
+from dynamic_config_loader.strategies.ini import IniStrategy
+from dynamic_config_loader.strategies.toml import TomlStrategy
 
 
 class StrategyFactory:
@@ -32,6 +35,10 @@ class StrategyFactory:
             ".yaml": YamlStrategy(),
             ".yml": YamlStrategy(),
             ".json": JsonStrategy(),
+            ".xml": XmlStrategy(),
+            ".ini": IniStrategy(),
+            ".conf": IniStrategy(),
+            ".toml": TomlStrategy(),
         }
 
     def get_strategy(self, extension: str) -> Optional[BaseStrategy]:

dynamic_config_loader-2.4.0/src/dynamic_config_loader/strategies/ini/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+INI Strategy Package Initializer.
+
+Exposes the concrete IniStrategy 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.ini.parser import parse_ini_file
+from dynamic_config_loader.strategies.ini.merger import execute_ini_deep_merge
+
+
+class IniStrategy(BaseStrategy):
+    """
+    Concrete Strategy implementation managing the processing life cycle of INI configurations.
+    """
+
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        return parse_ini_file(file_path)
+
+    def merge(
+        self,
+        base_dict: Dict[str, Any],
+        update_dict: Dict[str, Any],
+        path: str = "",
+        mask_secrets: bool = True,
+    ) -> None:
+        execute_ini_deep_merge(base_dict, update_dict, path=path, mask_secrets=mask_secrets)

dynamic_config_loader-2.4.0/src/dynamic_config_loader/strategies/ini/merger.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+INI Merging Strategy Module.
+
+Provides recursive tree-merging algorithms engineered to blend cascading INI layers.
+"""
+
+import logging
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def execute_ini_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 INI structure at path: {current_path}")
+            execute_ini_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 INI 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 INI path '{current_path}': {repr(base_dict[key])} -> {repr(value)}")
+                        else:
+                            logger.debug(f"Updating INI 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 INI key at path '{current_path}': {repr(value)}")
+                else:
+                    logger.debug(f"Adding new INI 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.4.0/src/dynamic_config_loader/strategies/ini/parser.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+INI Parsing Strategy Module.
+
+Provides isolated, low-level file stream ingestion utilities optimized
+for handling standard INI configuration assets.
+"""
+
+import configparser
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def parse_primitive(val: str) -> Any:
+    """
+    Parses a string value into standard Python primitives (bool, int, float, str).
+    """
+    val_lower = val.strip().lower()
+    if val_lower == "true":
+        return True
+    if val_lower == "false":
+        return False
+    try:
+        return int(val)
+    except ValueError:
+        pass
+    try:
+        return float(val)
+    except ValueError:
+        pass
+    return val.strip()
+
+
+def parse_ini_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Reads an INI configuration file asset from disk and returns a dictionary mapping.
+    """
+    try:
+        if file_path.stat().st_size == 0:
+            logger.info(f"Target INI file context is empty or unassigned: {file_path.name}")
+            return {}
+
+        config = configparser.ConfigParser()
+        config.read(file_path, encoding="utf-8")
+
+        result = {}
+        for section in config.sections():
+            result[section] = {}
+            for key, val in config.items(section):
+                result[section][key] = parse_primitive(val)
+
+        return result
+    except (configparser.Error, IOError, PermissionError) as e:
+        logger.exception(f"Failed to read or parse INI file: {file_path.name}", exc_info=e)
+        return {}

dynamic_config_loader-2.4.0/src/dynamic_config_loader/strategies/toml/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+TOML Strategy Package Initializer.
+
+Exposes the concrete TomlStrategy 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.toml.parser import parse_toml_file
+from dynamic_config_loader.strategies.toml.merger import execute_toml_deep_merge
+
+
+class TomlStrategy(BaseStrategy):
+    """
+    Concrete Strategy implementation managing the processing life cycle of TOML configurations.
+    """
+
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        return parse_toml_file(file_path)
+
+    def merge(
+        self,
+        base_dict: Dict[str, Any],
+        update_dict: Dict[str, Any],
+        path: str = "",
+        mask_secrets: bool = True,
+    ) -> None:
+        execute_toml_deep_merge(base_dict, update_dict, path=path, mask_secrets=mask_secrets)

dynamic_config_loader-2.4.0/src/dynamic_config_loader/strategies/toml/merger.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+TOML Merging Strategy Module.
+
+Provides recursive tree-merging algorithms engineered to blend cascading TOML layers.
+"""
+
+import logging
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def execute_toml_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 TOML structure at path: {current_path}")
+            execute_toml_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 TOML 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 TOML path '{current_path}': {repr(base_dict[key])} -> {repr(value)}")
+                        else:
+                            logger.debug(f"Updating TOML 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 TOML key at path '{current_path}': {repr(value)}")
+                else:
+                    logger.debug(f"Adding new TOML 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.4.0/src/dynamic_config_loader/strategies/toml/parser.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+TOML Parsing Strategy Module.
+
+Provides isolated, low-level file stream ingestion utilities optimized
+for handling standard TOML configuration assets.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+try:
+    import tomllib
+except ImportError:
+    # Fallback compatibility layer for Python < 3.11
+    import tomli as tomllib
+
+
+def parse_toml_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Reads a TOML configuration file asset from disk and returns a dictionary mapping.
+    """
+    try:
+        if file_path.stat().st_size == 0:
+            logger.info(f"Target TOML file context is empty or unassigned: {file_path.name}")
+            return {}
+
+        with open(file_path, "rb") as f:
+            data = tomllib.load(f)
+            if data is None:
+                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 Exception as e:
+        logger.exception(f"Failed to read or parse TOML file: {file_path.name}", exc_info=e)
+        return {}

dynamic_config_loader-2.4.0/src/dynamic_config_loader/strategies/xml/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+XML Strategy Package Initializer.
+
+Exposes the concrete XmlStrategy 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.xml.parser import parse_xml_file
+from dynamic_config_loader.strategies.xml.merger import execute_xml_deep_merge
+
+
+class XmlStrategy(BaseStrategy):
+    """
+    Concrete Strategy implementation managing the processing life cycle of XML configurations.
+    """
+
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        return parse_xml_file(file_path)
+
+    def merge(
+        self,
+        base_dict: Dict[str, Any],
+        update_dict: Dict[str, Any],
+        path: str = "",
+        mask_secrets: bool = True,
+    ) -> None:
+        execute_xml_deep_merge(base_dict, update_dict, path=path, mask_secrets=mask_secrets)

dynamic_config_loader-2.4.0/src/dynamic_config_loader/strategies/xml/merger.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+XML Merging Strategy Module.
+
+Provides recursive tree-merging algorithms engineered to blend cascading XML layers.
+"""
+
+import logging
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def execute_xml_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 XML structure at path: {current_path}")
+            execute_xml_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 XML 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 XML path '{current_path}': {repr(base_dict[key])} -> {repr(value)}")
+                        else:
+                            logger.debug(f"Updating XML 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 XML key at path '{current_path}': {repr(value)}")
+                else:
+                    logger.debug(f"Adding new XML 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.4.0/src/dynamic_config_loader/strategies/xml/parser.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+XML Parsing Strategy Module.
+
+Provides isolated, low-level file stream ingestion utilities optimized
+for handling standard XML configuration assets.
+"""
+
+import logging
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def parse_primitive(val: str) -> Any:
+    """
+    Parses a string value into standard Python primitives (bool, int, float, str).
+    """
+    val_lower = val.strip().lower()
+    if val_lower == "true":
+        return True
+    if val_lower == "false":
+        return False
+    try:
+        return int(val)
+    except ValueError:
+        pass
+    try:
+        return float(val)
+    except ValueError:
+        pass
+    return val.strip()
+
+
+def _xml_element_to_dict(element: ET.Element) -> Any:
+    """
+    Recursively translates XML elements into Python dictionaries.
+    """
+    children = list(element)
+    if not children:
+        text = element.text
+        if text is None:
+            return ""
+        return parse_primitive(text)
+
+    result = {}
+    for child in children:
+        result[child.tag] = _xml_element_to_dict(child)
+    return result
+
+
+def parse_xml_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Reads an XML configuration file asset from disk and returns a dictionary mapping.
+    """
+    try:
+        if file_path.stat().st_size == 0:
+            logger.info(f"Target XML file context is empty or unassigned: {file_path.name}")
+            return {}
+
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+        data = _xml_element_to_dict(root)
+
+        if data is None:
+            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 (ET.ParseError, IOError, PermissionError) as e:
+        logger.exception(f"Failed to read or parse XML file: {file_path.name}", exc_info=e)
+        return {}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.2.0
+Version: 2.4.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: 
@@ -210,7 +210,7 @@ Project-URL: Repository, https://gitlab.com/halfhiddencode/python-dynamic-config
 Project-URL: Issues, https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/issues
 Project-URL: Documentation, https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/tree/main/docs
 Project-URL: Changelog, https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CHANGELOG.md
-Keywords: config,configuration,dynamic-loader,cascading-config,deep-merge,strategy-pattern,yaml,json,devops
+Keywords: config,configuration,dynamic-loader,cascading-config,deep-merge,strategy-pattern,yaml,json,xml,toml,ini,conf,devops
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
@@ -232,12 +232,22 @@ License-File: LICENSE
 License-File: NOTICE
 License-File: AUTHORS
 Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 Dynamic: license-file
 
 # Dynamic Configuration Loader
 
 A lightweight, production-grade, strategy-driven configuration orchestration engine designed to dynamically discover, alphabetically sort, and recursively deep-merge multi-layered configuration files.
 
+## Supported Formats
+
+The orchestration engine natively parses and cascades the following configuration formats:
+* **YAML** (`.yaml`, `.yml`)
+* **JSON** (`.json`)
+* **XML** (`.xml`)
+* **TOML** (`.toml`)
+* **INI / Conf** (`.ini`, `.conf`)
+
 ---
 
 ```text
@@ -308,14 +318,14 @@ The complete enterprise documentation is organized under the Diátaxis framework
 
 | Track | Target Document | Description |
 | :--- | :--- | :--- |
-| **Getting Started** | [Getting Started Tutorial](docs/tutorials/getting_started.md) | Onboarding sequence, repeatable format tracks, and installation via GitLab Package Registry. |
-| **Operations Guide** | [Advanced Ingestion and Path Traversal Guide](docs/guides/user_usage.md) | Path parsing matrix, edge-case refusals, Central Config Manager pattern, and log masking safety details. |
-| **Contributor Guide** | [Format Strategy Contribution Guide](docs/guides/contributor_guide.md) | Abstract base strategy class signatures, factory registration hooks, and copy-pasteable JSON blueprints. |
-| **Technical Reference** | [Core Architecture Reference](docs/reference/architecture.md) | System design architecture, UML mapping, execution pipelines, and logging safety compliance matrices. |
+| **Getting Started** | [Getting Started Tutorial](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/tutorials/getting_started.md) | Onboarding sequence, repeatable format tracks, and installation via GitLab Package Registry. |
+| **Operations Guide** | [Advanced Ingestion and Path Traversal Guide](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/guides/user_usage.md) | Path parsing matrix, edge-case refusals, Central Config Manager pattern, and log masking safety details. |
+| **Contributor Guide** | [Format Strategy Contribution Guide](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/guides/contributor_guide.md) | Abstract base strategy class signatures, factory registration hooks, and copy-pasteable JSON blueprints. |
+| **Technical Reference** | [Core Architecture Reference](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/docs/reference/architecture.md) | System design architecture, UML mapping, execution pipelines, and logging safety compliance matrices. |
 
 ---
 
 ## Repository Ledgers
-* Version History: [CHANGELOG.md](CHANGELOG.md)
-* Security Policy: [SECURITY.md](SECURITY.md)
-* Contribution Protocols: [CONTRIBUTING.md](CONTRIBUTING.md)
+* Version History: [CHANGELOG.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CHANGELOG.md)
+* Security Policy: [SECURITY.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/SECURITY.md)
+* Contribution Protocols: [CONTRIBUTING.md](https://gitlab.com/halfhiddencode/python-dynamic-config-loader/-/blob/main/CONTRIBUTING.md)

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

@@ -13,15 +13,27 @@ 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/ini/__init__.py
+src/dynamic_config_loader/strategies/ini/merger.py
+src/dynamic_config_loader/strategies/ini/parser.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/toml/__init__.py
+src/dynamic_config_loader/strategies/toml/merger.py
+src/dynamic_config_loader/strategies/toml/parser.py
+src/dynamic_config_loader/strategies/xml/__init__.py
+src/dynamic_config_loader/strategies/xml/merger.py
+src/dynamic_config_loader/strategies/xml/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_ini_strategy.py
 tests/test_json_strategy.py
 tests/test_loader.py
-tests/test_logging_safety.py
+tests/test_logging_safety.py
+tests/test_toml_strategy.py
+tests/test_xml_strategy.py

dynamic_config_loader-2.4.0/src/dynamic_config_loader.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pyyaml>=6.0.1
+
+[:python_version < "3.11"]
+tomli>=2.0.1

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

@@ -4,6 +4,9 @@ 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
+from dynamic_config_loader.strategies.xml import XmlStrategy
+from dynamic_config_loader.strategies.ini import IniStrategy
+from dynamic_config_loader.strategies.toml import TomlStrategy
 
 
 class TestStrategyFactory(unittest.TestCase):
@@ -16,10 +19,18 @@ class TestStrategyFactory(unittest.TestCase):
         strategy_yaml = factory.get_strategy(".yaml")
         strategy_yml = factory.get_strategy(".yml")
         strategy_json = factory.get_strategy(".json")
+        strategy_xml = factory.get_strategy(".xml")
+        strategy_ini = factory.get_strategy(".ini")
+        strategy_conf = factory.get_strategy(".conf")
+        strategy_toml = factory.get_strategy(".toml")
 
         self.assertIsInstance(strategy_yaml, YamlStrategy)
         self.assertIsInstance(strategy_yml, YamlStrategy)
         self.assertIsInstance(strategy_json, JsonStrategy)
+        self.assertIsInstance(strategy_xml, XmlStrategy)
+        self.assertIsInstance(strategy_ini, IniStrategy)
+        self.assertIsInstance(strategy_conf, IniStrategy)
+        self.assertIsInstance(strategy_toml, TomlStrategy)
 
     def test_factory_case_insensitivity(self):
         """
@@ -28,17 +39,24 @@ class TestStrategyFactory(unittest.TestCase):
         strategy_mixed = factory.get_strategy(".YaMl")
         strategy_upper = factory.get_strategy(".YML")
         strategy_json_upper = factory.get_strategy(".JSON")
+        strategy_xml_upper = factory.get_strategy(".XML")
+        strategy_ini_upper = factory.get_strategy(".INI")
+        strategy_conf_upper = factory.get_strategy(".CONF")
+        strategy_toml_upper = factory.get_strategy(".TOML")
 
         self.assertIsInstance(strategy_mixed, YamlStrategy)
         self.assertIsInstance(strategy_upper, YamlStrategy)
         self.assertIsInstance(strategy_json_upper, JsonStrategy)
+        self.assertIsInstance(strategy_xml_upper, XmlStrategy)
+        self.assertIsInstance(strategy_ini_upper, IniStrategy)
+        self.assertIsInstance(strategy_conf_upper, IniStrategy)
+        self.assertIsInstance(strategy_toml_upper, TomlStrategy)
 
     def test_factory_unsupported_extensions(self):
         """
         Verifies that StrategyFactory returns None for unregistered extensions.
         """
-        self.assertIsNone(factory.get_strategy(".xml"))
-        self.assertIsNone(factory.get_strategy(".ini"))
+        self.assertIsNone(factory.get_strategy(".txt"))
 
 
 if __name__ == "__main__":

dynamic_config_loader-2.4.0/tests/test_ini_strategy.py

@@ -0,0 +1,118 @@
+# -*- 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.ini.parser import parse_ini_file
+from dynamic_config_loader.strategies.ini.merger import execute_ini_deep_merge
+
+
+class TestIniStrategy(unittest.TestCase):
+
+    def setUp(self):
+        self.TEST_DIR = Path(__file__).parent
+        self.base_file = self.TEST_DIR / "test_configs" / "base_config.ini"
+        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_ini_parsing(self):
+        """
+        Verifies that parse_ini_file correctly parses INI files and translates primitive types.
+        """
+        data = parse_ini_file(self.base_file)
+        self.assertEqual(data["app"]["name"], "Test INI Gateway")
+        self.assertFalse(data["app"]["debug_mode"])
+        self.assertEqual(data["database"]["port"], 5432)
+        self.assertEqual(data["database"]["host"], "127.0.0.1")
+
+    def test_ini_deep_merging(self):
+        """
+        Verifies recursive deep merges and type mismatch resolution for INI structures.
+        """
+        base = {
+            "app": {
+                "debug": False
+            },
+            "database": {
+                "host": "localhost",
+                "settings": {"pool": 10}
+            }
+        }
+        update = {
+            "app": {
+                "debug": True
+            },
+            "database": {
+                "settings": {"pool": 20, "timeout": 30}
+            }
+        }
+
+        execute_ini_deep_merge(base, update)
+
+        self.assertTrue(base["app"]["debug"])
+        self.assertEqual(base["database"]["host"], "localhost")
+        self.assertEqual(base["database"]["settings"]["pool"], 20)
+        self.assertEqual(base["database"]["settings"]["timeout"], 30)
+
+    def test_ini_loader_integration(self):
+        """
+        Verifies that DynamicConfigLoader correctly orchestrates baseline INI and directory overrides INI.
+        """
+        # 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 INI: Test INI Gateway, overrides folder has 01_dev_patch.ini overriding database host
+        self.assertEqual(result["app"]["name"], "Test INI Gateway")
+        self.assertTrue(result["app"]["debug_mode"])
+        self.assertEqual(result["database"]["host"], "ini-dev-cluster.local")
+        self.assertEqual(result["database"]["port"], 5432)
+
+    def test_ini_log_masking(self):
+        """
+        Verifies that logging of updates/additions for INI 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_ini_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_ini_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()

dynamic_config_loader-2.4.0/tests/test_toml_strategy.py

@@ -0,0 +1,118 @@
+# -*- 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.toml.parser import parse_toml_file
+from dynamic_config_loader.strategies.toml.merger import execute_toml_deep_merge
+
+
+class TestTomlStrategy(unittest.TestCase):
+
+    def setUp(self):
+        self.TEST_DIR = Path(__file__).parent
+        self.base_file = self.TEST_DIR / "test_configs" / "base_config.toml"
+        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_toml_parsing(self):
+        """
+        Verifies that parse_toml_file correctly parses TOML files.
+        """
+        data = parse_toml_file(self.base_file)
+        self.assertEqual(data["app"]["name"], "Test TOML Gateway")
+        self.assertFalse(data["app"]["debug_mode"])
+        self.assertEqual(data["database"]["port"], 5432)
+        self.assertEqual(data["database"]["host"], "127.0.0.1")
+
+    def test_toml_deep_merging(self):
+        """
+        Verifies recursive deep merges and type mismatch resolution for TOML structures.
+        """
+        base = {
+            "app": {
+                "debug": False
+            },
+            "database": {
+                "host": "localhost",
+                "settings": {"pool": 10}
+            }
+        }
+        update = {
+            "app": {
+                "debug": True
+            },
+            "database": {
+                "settings": {"pool": 20, "timeout": 30}
+            }
+        }
+
+        execute_toml_deep_merge(base, update)
+
+        self.assertTrue(base["app"]["debug"])
+        self.assertEqual(base["database"]["host"], "localhost")
+        self.assertEqual(base["database"]["settings"]["pool"], 20)
+        self.assertEqual(base["database"]["settings"]["timeout"], 30)
+
+    def test_toml_loader_integration(self):
+        """
+        Verifies that DynamicConfigLoader correctly orchestrates baseline TOML and directory overrides TOML.
+        """
+        # 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 TOML: Test TOML Gateway, overrides folder has 01_dev_patch.toml overriding database host
+        self.assertEqual(result["app"]["name"], "Test TOML Gateway")
+        self.assertTrue(result["app"]["debug_mode"])
+        self.assertEqual(result["database"]["host"], "toml-dev-cluster.local")
+        self.assertEqual(result["database"]["port"], 5432)
+
+    def test_toml_log_masking(self):
+        """
+        Verifies that logging of updates/additions for TOML 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_toml_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_toml_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()

dynamic_config_loader-2.4.0/tests/test_xml_strategy.py

@@ -0,0 +1,114 @@
+# -*- 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.xml.parser import parse_xml_file
+from dynamic_config_loader.strategies.xml.merger import execute_xml_deep_merge
+
+
+class TestXmlStrategy(unittest.TestCase):
+
+    def setUp(self):
+        self.TEST_DIR = Path(__file__).parent
+        self.base_file = self.TEST_DIR / "test_configs" / "base_config.xml"
+        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_xml_parsing(self):
+        """
+        Verifies that parse_xml_file correctly parses XML files and translates primitive types.
+        """
+        data = parse_xml_file(self.base_file)
+        self.assertEqual(data["app_name"], "Test XML Gateway")
+        self.assertFalse(data["debug_mode"])
+        self.assertEqual(data["database"]["port"], 5432)
+        self.assertEqual(data["database"]["host"], "127.0.0.1")
+
+    def test_xml_deep_merging(self):
+        """
+        Verifies recursive deep merges and type mismatch resolution for XML structures.
+        """
+        base = {
+            "debug": False,
+            "database": {
+                "host": "localhost",
+                "settings": {"pool": 10}
+            }
+        }
+        update = {
+            "debug": True,
+            "database": {
+                "settings": {"pool": 20, "timeout": 30}
+            }
+        }
+
+        execute_xml_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_xml_loader_integration(self):
+        """
+        Verifies that DynamicConfigLoader correctly orchestrates baseline XML and directory overrides XML.
+        """
+        # 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 XML: Test XML Gateway, overrides folder has 01_dev_patch.xml overriding database host
+        self.assertEqual(result["app_name"], "Test XML Gateway")
+        self.assertTrue(result["debug_mode"])
+        self.assertEqual(result["database"]["host"], "xml-dev-cluster.local")
+        self.assertEqual(result["database"]["port"], 5432)
+
+    def test_xml_log_masking(self):
+        """
+        Verifies that logging of updates/additions for XML 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_xml_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_xml_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()

dynamic_config_loader-2.2.0/src/dynamic_config_loader.egg-info/requires.txt

@@ -1 +0,0 @@
-pyyaml>=6.0.1