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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.4.0
+Version: 2.6.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,xml,toml,ini,conf,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
@@ -237,49 +237,67 @@ 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.
+A lightweight, production-grade, strategy-driven configuration orchestration engine designed to dynamically discover, cascade, and deep-merge multi-layered configuration files.
 
-## Supported Formats
+---
+
+## 📌 Quick Navigation Index
 
-The orchestration engine natively parses and cascades the following configuration formats:
-* **YAML** (`.yaml`, `.yml`)
-* **JSON** (`.json`)
-* **XML** (`.xml`)
-* **TOML** (`.toml`)
-* **INI / Conf** (`.ini`, `.conf`)
+- [⚡ Minimal Quick Start](#-quick-start-minimal-3-lines)
+- [📦 Installation](#-installation)
+- [⚙️ Supported Configuration Formats](#%EF%B8%8F-supported-configuration-formats)
+- [🔀 Multi-Layer Overrides & Environment Injection](#-multi-layer-overrides--environment-injection)
+- [📖 Documentation Index](#-documentation-index)
+- [🎨 System Architecture Visualizer](#-system-architecture)
 
 ---
 
-```text
-Copyright (C) 2026 Avinash Kumar <halfhiddencode AT gmail DOT com>
+### 🚀 Configuration Lifecycle Matrix: Minimal to Advanced
+
+| Lifecycle Phase | Component Requirement | How It Works in Code / Environment | Primary Purpose |
+| :--- | :--- | :--- | :--- |
+| **1. Local Dev (Coding Time)** | `[OPTIONAL FALLBACK]` | `loader = DynamicConfigLoader("config.yaml")` | Local fallback file for offline developer workstations. |
+| **2. Image Build (CI/CD Build Time)** | `[REQUIRED IN CODE]` | `loader = DynamicConfigLoader()` | **Image Immutability!** Zero hardcoded secrets in Docker image. |
+| **3. Deployment (K8s Runtime Time)** | `[OPTIONAL AT DEPLOYMENT]` | `export PYTHON_ADDITIONAL_CONFIG="/etc/config/prod.yaml"` | Mounts K8s ConfigMaps & Vault secrets into container at runtime. |
+| **4. Live Ops Overrides (Runtime)** | `[OPTIONAL AT RUNTIME]` | `export DCL_ENV_LOADER=true` <br> `export DCL_PORT=8080` | Overrides specific keys in memory dynamically without rebuilding image. |
+
+---
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
+### Minimal Execution Code Snippets
 
-    http://www.apache.org/licenses/LICENSE-2.0
+#### Mode 1: Container / Kubernetes Mode (`[RECOMMENDED FOR PROD]`)
+
+> [!NOTE]
+> **[OPTIONAL FILE PATH - CAN SKIP!]**
+> If you don't have a local config file, **YOU CAN SKIP IT!** In production container deployments, you do NOT need any hardcoded file paths in your code. The engine will handle configuration loading automatically at deployment time via environment variables (`PYTHON_ADDITIONAL_CONFIG` or `DCL_`).
+
+```python
+from dynamic_config_loader import DynamicConfigLoader
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+# Zero hardcoded file paths! Fully handled at deployment time
+loader = DynamicConfigLoader()
+config = loader.load()
 ```
 
----
+#### Mode 2: Local Development Mode (`[OPTIONAL FALLBACK]`)
+
+> [!NOTE]
+> **[LOCAL FALLBACK ONLY]**
+> Useful for local developer laptops so you can run `python app.py` offline without configuring environment variables.
+
+```python
+from dynamic_config_loader import DynamicConfigLoader
 
-## Project Metadata
-* **Maintainer:** Avinash Kumar
-* **Target Ecosystem:** Python 3.8+ / GitLab Source Hosting and PyPI Package Registry
-* **Official Repository:** [python-dynamic-config-loader](https://gitlab.com/halfhiddencode/python-dynamic-config-loader)
-* **Licensing:** Apache License, Version 2.0
-* **Core Design Patterns:** Strategy Pattern, Registry Factory
+# Optional local fallback file
+loader = DynamicConfigLoader("config.yaml")
+config = loader.load()
+```
 
 ---
 
-## Installation
+## 📦 Installation
 
-Install the package directly from PyPI:
+Install from PyPI via `pip`:
 
 ```bash
 pip install dynamic-config-loader
@@ -293,39 +311,67 @@ pip install -e .
 
 ---
 
-## Quick Start
+## ⚙️ Supported Configuration Formats
 
-```python
-import os
-from dynamic_config_loader import DynamicConfigLoader
+The orchestration engine natively ingests, parses, and cascades **7 configuration formats**:
 
-# 1. (Optional) Provide path override layers via system environment
-os.environ["PYTHON_ADDITIONAL_CONFIG"] = "/app/configs/overrides_directory"
+| Format | Extensions | Key Behavior & Conversion | Guide Link |
+| :--- | :--- | :--- | :--- |
+| **YAML** | `.yaml`, `.yml` | Native YAML indentation & deep dictionary parsing | [View Details](docs/guides/user_usage.md#71-yaml-strategy-yamlstrategy) |
+| **JSON** | `.json` | Strict JSON objects & typed arrays | [View Details](docs/guides/user_usage.md#72-json-strategy-jsonstrategy) |
+| **Dotenv** | `.env` | **100% Flat Keys** (`SERVICE_GATEWAY_NAME` $\rightarrow$ `config["service_gateway_name"]`) | [View Details](docs/guides/user_usage.md#87-dotenv-strategy-envstrategy) |
+| **TOML** | `.toml` | Section headers (`[table]`), inline tables, & datetimes | [View Details](docs/guides/user_usage.md#74-toml-strategy-tomlstrategy) |
+| **INI / Conf** | `.ini`, `.conf` | Section headers (`[section]`) & automatic primitive type casting | [View Details](docs/guides/user_usage.md#75-ini--conf-strategy-inistrategy) |
+| **Java Properties**| `.properties` | Dot notation (`app.database.port=5432` $\rightarrow$ `app.database.port`) | [View Details](docs/guides/user_usage.md#76-java-properties-strategy-propertiesstrategy) |
+| **XML** | `.xml` | Tag element hierarchies auto-converted into Python dicts | [View Details](docs/guides/user_usage.md#73-xml-strategy-xmlstrategy) |
 
-# 2. Instantiate with a local base configuration file
-loader = DynamicConfigLoader(default_config_path="/app/configs/base_defaults.yaml")
+---
 
-# 3. Load and compile configurations
-config = loader.load()
-print(config["database"]["host"])
+## 🔀 Multi-Layer Overrides & Environment Injection
+
+<details>
+<summary><b>Click to expand Advanced Environment Overrides & Logging Options</b></summary>
+
+### 1. External File/Directory Overrides (`PYTHON_ADDITIONAL_CONFIG`)
+Specify an external file or directory of override files via system environment variables:
+
+```bash
+export PYTHON_ADDITIONAL_CONFIG="/etc/app/production_overrides.yaml"
 ```
 
+### 2. Environment Variable Injection (`DCL_ENV_LOADER=true`)
+Inject or override specific keys dynamically at runtime using environment variables:
+
+```bash
+export DCL_ENV_LOADER=true
+export DCL_PORT=9000
+export DCL_LOG_LEVEL=info
+```
+
+### 3. Log Redaction Controls (`ENABLE_UNSAFE_LOGGING`)
+* **Default (Safe Mode):** Sensitive passwords and tokens are redacted (`[REDACTED]`) in logs.
+* **Unsafe Mode (`ENABLE_UNSAFE_LOGGING=true`):** Exposes raw values during local debug sessions.
+
+</details>
+
 ---
 
-## Documentation Index
+## 🎨 System Architecture
+
+![Master Architecture Pipeline & Deep Merge Visualizer](docs/images/master_architecture_deep_merge.svg)
+
+---
 
-The complete enterprise documentation is organized under the Diátaxis framework layout rules within the `docs/` directory. No emojis are used in the index or guidelines.
+## 📖 Documentation Index
 
-| Track | Target Document | Description |
+| Guide Track | Link | Description |
 | :--- | :--- | :--- |
-| **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. |
+| **🚀 Getting Started Tutorial** | [getting_started.md](docs/tutorials/getting_started.md) | Step-by-step onboarding & minimal execution tracks. |
+| **📖 Operations & Usage Guide** | [user_usage.md](docs/guides/user_usage.md) | Complete format matrix, K8s/DevOps deployment scenarios, & path edge cases. |
+| **🛠️ Contributor Guide** | [contributor_guide.md](docs/guides/contributor_guide.md) | Adding custom format strategies & factory registry hooks. |
+| **🏗️ Architecture Reference** | [architecture.md](docs/reference/architecture.md) | System design, UML diagrams, & deep merge algorithms. |
 
 ---
 
-## Repository Ledgers
-* 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)
+## 📜 License
+Licensed under the [Apache License, Version 2.0](LICENSE).

dynamic_config_loader-2.6.0/README.md

@@ -0,0 +1,140 @@
+# Dynamic Configuration Loader
+
+A lightweight, production-grade, strategy-driven configuration orchestration engine designed to dynamically discover, cascade, and deep-merge multi-layered configuration files.
+
+---
+
+## 📌 Quick Navigation Index
+
+- [⚡ Minimal Quick Start](#-quick-start-minimal-3-lines)
+- [📦 Installation](#-installation)
+- [⚙️ Supported Configuration Formats](#%EF%B8%8F-supported-configuration-formats)
+- [🔀 Multi-Layer Overrides & Environment Injection](#-multi-layer-overrides--environment-injection)
+- [📖 Documentation Index](#-documentation-index)
+- [🎨 System Architecture Visualizer](#-system-architecture)
+
+---
+
+### 🚀 Configuration Lifecycle Matrix: Minimal to Advanced
+
+| Lifecycle Phase | Component Requirement | How It Works in Code / Environment | Primary Purpose |
+| :--- | :--- | :--- | :--- |
+| **1. Local Dev (Coding Time)** | `[OPTIONAL FALLBACK]` | `loader = DynamicConfigLoader("config.yaml")` | Local fallback file for offline developer workstations. |
+| **2. Image Build (CI/CD Build Time)** | `[REQUIRED IN CODE]` | `loader = DynamicConfigLoader()` | **Image Immutability!** Zero hardcoded secrets in Docker image. |
+| **3. Deployment (K8s Runtime Time)** | `[OPTIONAL AT DEPLOYMENT]` | `export PYTHON_ADDITIONAL_CONFIG="/etc/config/prod.yaml"` | Mounts K8s ConfigMaps & Vault secrets into container at runtime. |
+| **4. Live Ops Overrides (Runtime)** | `[OPTIONAL AT RUNTIME]` | `export DCL_ENV_LOADER=true` <br> `export DCL_PORT=8080` | Overrides specific keys in memory dynamically without rebuilding image. |
+
+---
+
+### Minimal Execution Code Snippets
+
+#### Mode 1: Container / Kubernetes Mode (`[RECOMMENDED FOR PROD]`)
+
+> [!NOTE]
+> **[OPTIONAL FILE PATH - CAN SKIP!]**
+> If you don't have a local config file, **YOU CAN SKIP IT!** In production container deployments, you do NOT need any hardcoded file paths in your code. The engine will handle configuration loading automatically at deployment time via environment variables (`PYTHON_ADDITIONAL_CONFIG` or `DCL_`).
+
+```python
+from dynamic_config_loader import DynamicConfigLoader
+
+# Zero hardcoded file paths! Fully handled at deployment time
+loader = DynamicConfigLoader()
+config = loader.load()
+```
+
+#### Mode 2: Local Development Mode (`[OPTIONAL FALLBACK]`)
+
+> [!NOTE]
+> **[LOCAL FALLBACK ONLY]**
+> Useful for local developer laptops so you can run `python app.py` offline without configuring environment variables.
+
+```python
+from dynamic_config_loader import DynamicConfigLoader
+
+# Optional local fallback file
+loader = DynamicConfigLoader("config.yaml")
+config = loader.load()
+```
+
+---
+
+## 📦 Installation
+
+Install from PyPI via `pip`:
+
+```bash
+pip install dynamic-config-loader
+```
+
+Or install in editable mode for local development:
+
+```bash
+pip install -e .
+```
+
+---
+
+## ⚙️ Supported Configuration Formats
+
+The orchestration engine natively ingests, parses, and cascades **7 configuration formats**:
+
+| Format | Extensions | Key Behavior & Conversion | Guide Link |
+| :--- | :--- | :--- | :--- |
+| **YAML** | `.yaml`, `.yml` | Native YAML indentation & deep dictionary parsing | [View Details](docs/guides/user_usage.md#71-yaml-strategy-yamlstrategy) |
+| **JSON** | `.json` | Strict JSON objects & typed arrays | [View Details](docs/guides/user_usage.md#72-json-strategy-jsonstrategy) |
+| **Dotenv** | `.env` | **100% Flat Keys** (`SERVICE_GATEWAY_NAME` $\rightarrow$ `config["service_gateway_name"]`) | [View Details](docs/guides/user_usage.md#87-dotenv-strategy-envstrategy) |
+| **TOML** | `.toml` | Section headers (`[table]`), inline tables, & datetimes | [View Details](docs/guides/user_usage.md#74-toml-strategy-tomlstrategy) |
+| **INI / Conf** | `.ini`, `.conf` | Section headers (`[section]`) & automatic primitive type casting | [View Details](docs/guides/user_usage.md#75-ini--conf-strategy-inistrategy) |
+| **Java Properties**| `.properties` | Dot notation (`app.database.port=5432` $\rightarrow$ `app.database.port`) | [View Details](docs/guides/user_usage.md#76-java-properties-strategy-propertiesstrategy) |
+| **XML** | `.xml` | Tag element hierarchies auto-converted into Python dicts | [View Details](docs/guides/user_usage.md#73-xml-strategy-xmlstrategy) |
+
+---
+
+## 🔀 Multi-Layer Overrides & Environment Injection
+
+<details>
+<summary><b>Click to expand Advanced Environment Overrides & Logging Options</b></summary>
+
+### 1. External File/Directory Overrides (`PYTHON_ADDITIONAL_CONFIG`)
+Specify an external file or directory of override files via system environment variables:
+
+```bash
+export PYTHON_ADDITIONAL_CONFIG="/etc/app/production_overrides.yaml"
+```
+
+### 2. Environment Variable Injection (`DCL_ENV_LOADER=true`)
+Inject or override specific keys dynamically at runtime using environment variables:
+
+```bash
+export DCL_ENV_LOADER=true
+export DCL_PORT=9000
+export DCL_LOG_LEVEL=info
+```
+
+### 3. Log Redaction Controls (`ENABLE_UNSAFE_LOGGING`)
+* **Default (Safe Mode):** Sensitive passwords and tokens are redacted (`[REDACTED]`) in logs.
+* **Unsafe Mode (`ENABLE_UNSAFE_LOGGING=true`):** Exposes raw values during local debug sessions.
+
+</details>
+
+---
+
+## 🎨 System Architecture
+
+![Master Architecture Pipeline & Deep Merge Visualizer](docs/images/master_architecture_deep_merge.svg)
+
+---
+
+## 📖 Documentation Index
+
+| Guide Track | Link | Description |
+| :--- | :--- | :--- |
+| **🚀 Getting Started Tutorial** | [getting_started.md](docs/tutorials/getting_started.md) | Step-by-step onboarding & minimal execution tracks. |
+| **📖 Operations & Usage Guide** | [user_usage.md](docs/guides/user_usage.md) | Complete format matrix, K8s/DevOps deployment scenarios, & path edge cases. |
+| **🛠️ Contributor Guide** | [contributor_guide.md](docs/guides/contributor_guide.md) | Adding custom format strategies & factory registry hooks. |
+| **🏗️ Architecture Reference** | [architecture.md](docs/reference/architecture.md) | System design, UML diagrams, & deep merge algorithms. |
+
+---
+
+## 📜 License
+Licensed under the [Apache License, Version 2.0](LICENSE).

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dynamic-config-loader"
-version = "2.4.0"
+version = "2.6.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"
@@ -27,6 +27,8 @@ keywords = [
     "toml",
     "ini",
     "conf",
+    "properties",
+    "dotenv",
     "devops"
 ]
 

{dynamic_config_loader-2.4.0 → dynamic_config_loader-2.6.0}/src/dynamic_config_loader/environment.py

@@ -56,11 +56,21 @@ def inject_environment_variables(
         if env_key.startswith(prefix):
             # Strip prefix
             sliced_key = env_key[len(prefix):]
-            if not sliced_key:
-                continue
+            parsed_val = _parse_env_value(env_val)
+
+            flat_key = sliced_key.strip().lower()
+
+            # Resolution order:
+            # 1. Direct flat key match in config_data (e.g. DCL_TEST_NAME -> config_data["test_name"])
+            # 2. Double-underscore '__' explicit namespace splitting (e.g. DCL_AUTH__TENANT_ID -> config_data["auth"]["tenant_id"])
+            # 3. Single-underscore '_' nested path splitting (e.g. DCL_DATABASE_PORT -> config_data["database"]["port"])
+            if flat_key in config_data:
+                parts = [flat_key]
+            elif "__" in sliced_key:
+                parts = [p.lower() for p in sliced_key.split("__") if p]
+            else:
+                parts = [p.lower() for p in sliced_key.split("_") if p]
 
-            # Case Normalization and tokenizing
-            parts = [p.lower() for p in sliced_key.split("_") if p]
             if not parts:
                 continue
 

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

@@ -19,6 +19,8 @@ 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:
@@ -39,6 +41,8 @@ class StrategyFactory:
             ".ini": IniStrategy(),
             ".conf": IniStrategy(),
             ".toml": TomlStrategy(),
+            ".env": EnvStrategy(),
+            ".properties": PropertiesStrategy(),
         }
 
     def get_strategy(self, extension: str) -> Optional[BaseStrategy]:

dynamic_config_loader-2.6.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.6.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.6.0/src/dynamic_config_loader/strategies/env/parser.py

@@ -0,0 +1,71 @@
+# -*- 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()
+                if not line or line.startswith("#") or line.startswith("!") or "=" not in line:
+                    continue
+
+                key, val = line.split("=", 1)
+                key = key.strip().lower()
+                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)
+                data[key] = 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.6.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
+        )