dynamic-config-loader 2.3.0__tar.gz → 2.5.0__tar.gz

{dynamic_config_loader-2.3.0/src/dynamic_config_loader.egg-info → dynamic_config_loader-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.3.0
+Version: 2.5.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,properties,dotenv,devops
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
@@ -232,12 +232,24 @@ 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`)
+* **Java Properties** (`.properties`)
+* **Dotenv** (`.env`)
+
 ---
 
 ```text

{dynamic_config_loader-2.3.0 → dynamic_config_loader-2.5.0}/README.md

@@ -2,6 +2,17 @@
 
 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`)
+* **Java Properties** (`.properties`)
+* **Dotenv** (`.env`)
+
 ---
 
 ```text

{dynamic_config_loader-2.3.0 → dynamic_config_loader-2.5.0}/pyproject.toml

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

{dynamic_config_loader-2.3.0 → dynamic_config_loader-2.5.0}/src/dynamic_config_loader/strategies/__init__.py

@@ -17,6 +17,10 @@ from dynamic_config_loader.strategies.base_strategy import BaseStrategy
 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
+from dynamic_config_loader.strategies.env import EnvStrategy
+from dynamic_config_loader.strategies.properties import PropertiesStrategy
 
 
 class StrategyFactory:
@@ -34,6 +38,11 @@ class StrategyFactory:
             ".yml": YamlStrategy(),
             ".json": JsonStrategy(),
             ".xml": XmlStrategy(),
+            ".ini": IniStrategy(),
+            ".conf": IniStrategy(),
+            ".toml": TomlStrategy(),
+            ".env": EnvStrategy(),
+            ".properties": PropertiesStrategy(),
         }
 
     def get_strategy(self, extension: str) -> Optional[BaseStrategy]:

dynamic_config_loader-2.5.0/src/dynamic_config_loader/strategies/env/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+Env Strategy Entrypoint.
+
+Exposes the EnvStrategy wrapper subclassing BaseStrategy.
+"""
+
+from pathlib import Path
+from typing import Any, Dict
+from dynamic_config_loader.strategies.base_strategy import BaseStrategy
+from dynamic_config_loader.strategies.env.parser import parse_env_file
+from dynamic_config_loader.strategies.env.merger import execute_env_deep_merge
+
+
+class EnvStrategy(BaseStrategy):
+    """
+    Strategy implementation managing the parsing and deep-merging of dotenv (.env) assets.
+    """
+
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        return parse_env_file(file_path)
+
+    def merge(
+        self,
+        base_dict: Dict[str, Any],
+        update_dict: Dict[str, Any],
+        path: str = "",
+        mask_secrets: bool = True,
+    ) -> None:
+        execute_env_deep_merge(
+            base_dict, update_dict, path=path, mask_secrets=mask_secrets
+        )

dynamic_config_loader-2.5.0/src/dynamic_config_loader/strategies/env/merger.py

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

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+Env Parsing Strategy Module.
+
+Provides isolated, low-level file stream ingestion utilities optimized
+for handling standard dotenv configuration assets.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_env_file_value(val: str) -> Any:
+    """
+    Parses env string values into standard 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_env_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Reads a dotenv configuration file asset from disk and returns a dictionary mapping.
+    """
+    data: Dict[str, Any] = {}
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                # Ignore empty lines and comment lines starting with '#'
+                if not line or line.startswith("#"):
+                    continue
+
+                if "=" not in line:
+                    continue
+
+                key, val = line.split("=", 1)
+                key = key.strip()
+                val = val.strip()
+
+                if not key:
+                    continue
+
+                # Strip surrounding double or single quotes
+                if len(val) >= 2 and (
+                    (val[0] == '"' and val[-1] == '"') or (val[0] == "'" and val[-1] == "'")
+                ):
+                    val = val[1:-1]
+
+                parsed_val = _parse_env_file_value(val)
+
+                # Tokenize key by single underscore delimiter to align with env injection track
+                parts = [p.lower() for p in key.split("_") if p]
+                if not parts:
+                    continue
+
+                curr = data
+                for part in parts[:-1]:
+                    if part not in curr or not isinstance(curr[part], dict):
+                        curr[part] = {}
+                    curr = curr[part]
+                curr[parts[-1]] = parsed_val
+
+    except (IOError, PermissionError) as e:
+        logger.exception(f"Failed to read or parse dotenv file: {file_path.name}", exc_info=e)
+
+    return data

dynamic_config_loader-2.5.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.5.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.5.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.5.0/src/dynamic_config_loader/strategies/properties/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+Java Properties Strategy Entrypoint.
+
+Exposes the PropertiesStrategy wrapper subclassing BaseStrategy.
+"""
+
+from pathlib import Path
+from typing import Any, Dict
+from dynamic_config_loader.strategies.base_strategy import BaseStrategy
+from dynamic_config_loader.strategies.properties.parser import parse_properties_file
+from dynamic_config_loader.strategies.properties.merger import execute_properties_deep_merge
+
+
+class PropertiesStrategy(BaseStrategy):
+    """
+    Strategy implementation managing the parsing and deep-merging of Java properties assets.
+    """
+
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        return parse_properties_file(file_path)
+
+    def merge(
+        self,
+        base_dict: Dict[str, Any],
+        update_dict: Dict[str, Any],
+        path: str = "",
+        mask_secrets: bool = True,
+    ) -> None:
+        execute_properties_deep_merge(
+            base_dict, update_dict, path=path, mask_secrets=mask_secrets
+        )

dynamic_config_loader-2.5.0/src/dynamic_config_loader/strategies/properties/merger.py

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

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+Properties Parsing Strategy Module.
+
+Provides isolated, low-level file stream ingestion utilities optimized
+for handling standard properties configuration assets.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_properties_value(val: str) -> Any:
+    """
+    Parses properties string values into standard 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_properties_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Reads a .properties configuration file asset from disk and returns a dictionary mapping.
+    """
+    data: Dict[str, Any] = {}
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                # Ignore empty lines and comment lines starting with '#' or '!'
+                if not line or line.startswith("#") or line.startswith("!"):
+                    continue
+
+                # Properties delimiter could be '=' or ':'
+                delimiter_idx = -1
+                for idx, char in enumerate(line):
+                    if char in ("=", ":"):
+                        delimiter_idx = idx
+                        break
+
+                if delimiter_idx == -1:
+                    continue
+
+                key = line[:delimiter_idx].strip()
+                val = line[delimiter_idx + 1:].strip()
+
+                if not key:
+                    continue
+
+                parsed_val = _parse_properties_value(val)
+
+                # Tokenize key by dot delimiter to create hierarchical structure
+                parts = [p.lower() for p in key.split(".") if p]
+                if not parts:
+                    continue
+
+                curr = data
+                for part in parts[:-1]:
+                    if part not in curr or not isinstance(curr[part], dict):
+                        curr[part] = {}
+                    curr = curr[part]
+                curr[parts[-1]] = parsed_val
+
+    except (IOError, PermissionError) as e:
+        logger.exception(f"Failed to read or parse properties file: {file_path.name}", exc_info=e)
+
+    return data