configplusplus 0.1.0__py3-none-any.whl

configplusplus/__init__.py

@@ -0,0 +1,20 @@
+"""
+ConfigPlusPlus - Beautiful configuration management for Python
+"""
+
+__version__ = "0.1.0"
+__author__ = "Florian BARRE"
+
+from configplusplus.base import ConfigBase, ConfigMeta
+from configplusplus.env_loader import EnvConfigLoader
+from configplusplus.yaml_loader import YamlConfigLoader
+from configplusplus.utils import env, safe_load_envs
+
+__all__ = [
+    "ConfigBase",
+    "ConfigMeta",
+    "EnvConfigLoader",
+    "YamlConfigLoader",
+    "env",
+    "safe_load_envs",
+]

configplusplus/base.py

@@ -0,0 +1,138 @@
+"""
+Base classes for configuration management with beautiful display
+"""
+
+from typing import Any, Dict
+import pathlib
+
+
+class ConfigMeta(type):
+    """
+    Metaclass to provide pretty printing and helpers on configuration classes.
+
+    Automatically adds:
+    - to_dict(): Convert config to dictionary
+    - Pretty __repr__ with grouped display
+    - Secret masking for sensitive values
+    """
+
+    def to_dict(cls) -> Dict[str, Any]:
+        """
+        Return all UPPERCASE, non-callable attributes as a dict.
+
+        Returns:
+            Dictionary containing all configuration values
+        """
+        return {
+            k: v for k, v in cls.__dict__.items() if k.isupper() and not callable(v)
+        }
+
+    def _mask_if_secret(cls, key: str, value: Any) -> Any:
+        """
+        Mask potentially sensitive values (API keys, tokens, secrets, passwords).
+
+        Args:
+            key: Configuration key name
+            value: Configuration value
+
+        Returns:
+            Masked value if sensitive, original value otherwise
+        """
+        if value is None:
+            return None
+
+        key_upper = key.upper()
+        sensitive_keywords = ("SECRET", "API_KEY", "PASSWORD", "TOKEN", "CREDENTIAL")
+
+        if any(keyword in key_upper for keyword in sensitive_keywords):
+            s = str(value)
+            if len(s) <= 6:
+                return "***hidden***"
+            return f"{s[:3]}…{s[-2:]} (hidden)"
+
+        return value
+
+    def _grouped_items(cls) -> Dict[str, list]:
+        """
+        Group configuration items by prefix before first underscore.
+
+        Example:
+            QDRANT_URL and QDRANT_PORT -> grouped under "QDRANT"
+
+        Returns:
+            Dictionary mapping prefixes to list of (key, value) tuples
+        """
+        items = cls.to_dict()
+        groups: Dict[str, list] = {}
+
+        for k, v in items.items():
+            prefix = k.split("_", 1)[0]  # e.g., QDRANT_URL -> QDRANT
+            groups.setdefault(prefix, []).append((k, v))
+
+        return groups
+
+    def __repr__(cls) -> str:
+        """
+        Pretty multi-line representation of the configuration.
+
+        Returns:
+            Formatted string with grouped configuration display
+        """
+        lines = ["\n"]
+        lines.append("╔════════════════════════════════════════════╗")
+        lines.append(f"║  {cls.__name__.upper().center(40)}  ║")
+        lines.append("╚════════════════════════════════════════════╝")
+
+        groups = cls._grouped_items()
+
+        # Sort groups by name for deterministic output
+        for prefix in sorted(groups.keys()):
+            lines.append("")  # blank line
+            lines.append(f"▶ {prefix}")
+            items = groups[prefix]
+
+            if not items:
+                continue
+
+            max_key_len = max(len(k) for k, _ in items)
+
+            for key, value in sorted(items, key=lambda kv: kv[0]):
+                display_value = cls._mask_if_secret(key, value)
+
+                # Make paths nicer to read
+                if isinstance(display_value, pathlib.Path):
+                    display_value = str(display_value.resolve())
+
+                lines.append(f"    {key.ljust(max_key_len)} = {display_value!r}")
+
+        lines.append("")  # final blank line
+        return "\n".join(lines)
+
+
+class ConfigBase(metaclass=ConfigMeta):
+    """
+    Base class for all configuration classes.
+
+    Provides:
+    - Pretty printing via metaclass
+    - to_dict() method for serialization
+    - Automatic grouping and display of config values
+
+    Usage:
+        class MyConfig(ConfigBase):
+            DATABASE_HOST = "localhost"
+            DATABASE_PORT = 5432
+            SECRET_API_KEY = "secret123"
+
+        print(MyConfig)  # Pretty formatted output
+    """
+
+    def __repr__(self) -> str:
+        """Instance-level repr uses the class pretty repr."""
+        # Call the metaclass __repr__ directly
+        return ConfigMeta.__repr__(type(self))
+
+    def __str__(self) -> str:
+        """Instance-level str uses the class pretty repr."""
+        # Call the metaclass __repr__ directly
+        return ConfigMeta.__repr__(type(self))

configplusplus/env_loader.py

@@ -0,0 +1,134 @@
+"""
+Environment variable based configuration loader
+"""
+
+from typing import Any
+from configplusplus.base import ConfigBase
+
+
+class EnvConfigLoader(ConfigBase):
+    """
+    Base class for environment variable based configuration.
+
+    This class is 100% static with no __init__ - configuration is loaded
+    from environment variables at class definition time.
+
+    Features:
+    - Automatic pretty printing via ConfigBase
+    - Secret masking for sensitive values
+    - Grouped display by configuration prefix
+
+    Usage:
+        from configplusplus import EnvConfigLoader, env
+
+        class MyConfig(EnvConfigLoader):
+            # Required variables
+            DATABASE_HOST = env("DATABASE_HOST")
+            DATABASE_PORT = env("DATABASE_PORT", cast=int)
+
+            # Optional with defaults
+            DEBUG_MODE = env("DEBUG_MODE", cast=bool, default=False)
+
+            # Paths
+            DATA_DIR = env("DATA_DIR", cast=pathlib.Path)
+
+            # Secrets (automatically masked in output)
+            SECRET_API_KEY = env("SECRET_API_KEY")
+
+        # Use as static class
+        print(MyConfig.DATABASE_HOST)
+        print(MyConfig)  # Pretty formatted output
+
+    Helper Methods:
+        You can use the env() helper function with various options:
+
+        env(key)                                    # Required, str
+        env(key, cast=int)                          # Required, int
+        env(key, default="value")                   # Optional with default
+        env(key, cast=bool, default=False)          # Bool casting
+        env(key, cast=pathlib.Path)                 # Path casting
+        env_optional(key, default=None)             # Explicitly optional
+
+    Boolean Casting:
+        When cast=bool, these strings are considered False:
+        - "false", "False", "FALSE"
+        - "0"
+        - "no", "No", "NO"
+        - "" (empty string)
+
+        All other values are considered True.
+
+    Secret Masking:
+        Variables containing these keywords are automatically masked:
+        - SECRET
+        - API_KEY
+        - PASSWORD
+        - TOKEN
+        - CREDENTIAL
+
+        Example output: "sec...et (hidden)"
+    """
+
+    @classmethod
+    def get(cls, key: str, default: Any = None) -> Any:
+        """
+        Get a configuration value by key.
+
+        Args:
+            key: Configuration key (case-insensitive)
+            default: Default value if key not found
+
+        Returns:
+            Configuration value or default
+
+        Example:
+            >>> MyConfig.get("DATABASE_HOST")
+            "localhost"
+
+            >>> MyConfig.get("MISSING_KEY", default="fallback")
+            "fallback"
+        """
+        return getattr(cls, key.upper(), default)
+
+    @classmethod
+    def has(cls, key: str) -> bool:
+        """
+        Check if a configuration key exists.
+
+        Args:
+            key: Configuration key (case-insensitive)
+
+        Returns:
+            True if key exists, False otherwise
+
+        Example:
+            >>> MyConfig.has("DATABASE_HOST")
+            True
+
+            >>> MyConfig.has("MISSING_KEY")
+            False
+        """
+        return hasattr(cls, key.upper())
+
+    @classmethod
+    def validate(cls) -> None:
+        """
+        Validate that all required configuration is present.
+
+        Override this method in subclasses to add custom validation logic.
+
+        Raises:
+            RuntimeError: If validation fails
+
+        Example:
+            class MyConfig(EnvConfigLoader):
+                DATABASE_HOST = env("DATABASE_HOST")
+                DATABASE_PORT = env("DATABASE_PORT", cast=int)
+
+                @classmethod
+                def validate(cls) -> None:
+                    super().validate()
+                    if cls.DATABASE_PORT < 1024:
+                        raise RuntimeError("DATABASE_PORT must be >= 1024")
+        """
+        pass

configplusplus/utils.py

@@ -0,0 +1,118 @@
+"""
+Utility functions for configuration management
+"""
+
+from typing import Any, TypeVar
+from dotenv import load_dotenv
+from loggerplusplus import loggerplusplus
+from loggerplusplus import formats as lpp_formats
+import sys
+import os
+
+T = TypeVar("T")
+
+
+def safe_load_envs(env_path: str = ".env", verbose: bool = True) -> bool:
+    """
+    Load environment variables from .env file with detailed logging.
+
+    Args:
+        env_path: Path to the .env file (default: ".env")
+        verbose: Whether to log loading information (default: True)
+
+    Returns:
+        True if file was loaded successfully, False otherwise
+
+    Example:
+        >>> safe_load_envs()
+        ✅ Loaded environment file: .env
+        True
+    """
+    if verbose:
+        loggerplusplus.add(
+            sink=sys.stdout,
+            level="DEBUG",
+            format=lpp_formats.ShortFormat(),
+        )
+        env_logger = loggerplusplus.bind(identifier="ENV_LOADER")
+
+    # Try with leading slash first (absolute path)
+    success = load_dotenv(f"/{env_path}")
+
+    if success and verbose:
+        env_logger.info(f"✅ Loaded environment file: /{env_path}")
+    elif not success:
+        # Try without leading slash (relative path)
+        success = load_dotenv(env_path)
+        if success and verbose:
+            env_logger.info(f"✅ Loaded environment file: {env_path}")
+        elif verbose:
+            env_logger.info(f"ℹ️ Environment file not found: {env_path}")
+
+    if verbose:
+        loggerplusplus.remove()
+
+    return success
+
+
+def env(
+    key: str, *, default: Any = None, cast: type = str, required: bool = True
+) -> Any:
+    """
+    Read environment variable with optional type casting and default value.
+
+    Args:
+        key: Environment variable name
+        default: Default value if not found (default: None)
+        cast: Type to cast the value to (default: str)
+        required: Whether the variable is required (default: True)
+
+    Returns:
+        The environment variable value, cast to the specified type
+
+    Raises:
+        RuntimeError: If required variable is missing and no default provided
+
+    Examples:
+        >>> env("DATABASE_PORT", cast=int, default=5432)
+        5432
+
+        >>> env("DEBUG_MODE", cast=bool, default=False)
+        False
+
+        >>> env("API_KEY")  # Required by default
+        RuntimeError: missing required env var API_KEY
+    """
+    val = os.getenv(key, default)
+
+    if val is None:
+        if required:
+            raise RuntimeError(f"missing required env var {key}")
+        return None
+
+    # Special handling for boolean casting from string
+    if cast == bool and isinstance(val, str):
+        return val.strip().lower() not in {"false", "0", "no", ""}
+
+    return cast(val)
+
+
+def env_optional(key: str, *, default: Any = None, cast: type = str) -> Any:
+    """
+    Read optional environment variable with type casting.
+
+    Convenience wrapper for env() with required=False.
+
+    Args:
+        key: Environment variable name
+        default: Default value if not found (default: None)
+        cast: Type to cast the value to (default: str)
+
+    Returns:
+        The environment variable value, cast to the specified type, or default
+
+    Example:
+        >>> env_optional("OPTIONAL_FEATURE", cast=bool, default=False)
+        False
+    """
+    return env(key, default=default, cast=cast, required=False)

configplusplus/yaml_loader.py

@@ -0,0 +1,260 @@
+"""
+YAML file based configuration loader
+"""
+
+from typing import Any, Dict
+import pathlib
+import yaml
+from loggerplusplus import loggerplusplus
+
+
+class YamlConfigLoader:
+    """
+    Base class for YAML file based configuration.
+
+    This class requires instantiation with a path to a YAML file.
+    The YAML file is loaded in __init__, then __post_init__ is called
+    for custom parsing logic.
+
+    Features:
+    - Automatic YAML loading
+    - Post-initialization hook for custom parsing
+    - Access to raw config data
+    - Pretty printing support
+
+    Usage:
+        from configplusplus import YamlConfigLoader
+
+        class MyYamlConfig(YamlConfigLoader):
+            def __post_init__(self) -> None:
+                # Parse the loaded YAML data
+                self.database_host = self._raw_config["database"]["host"]
+                self.database_port = self._raw_config["database"]["port"]
+
+                # Parse nested structures
+                self.features = [
+                    Feature(**feature_data)
+                    for feature_data in self._raw_config["features"]
+                ]
+
+        # Instantiate with path
+        config = MyYamlConfig("config.yaml")
+        print(config.database_host)
+        print(config)  # Pretty formatted output
+
+    YAML File Example:
+        database:
+          host: localhost
+          port: 5432
+
+        features:
+          - name: search
+            enabled: true
+          - name: export
+            enabled: false
+
+    Attributes:
+        config_path: Path to the loaded YAML file
+        _raw_config: Raw dictionary loaded from YAML
+        logger: LoggerPlusPlus logger instance
+    """
+
+    def __init__(self, config_path: str | pathlib.Path) -> None:
+        """
+        Initialize the YAML config loader.
+
+        Args:
+            config_path: Path to the YAML configuration file
+
+        Raises:
+            FileNotFoundError: If the configuration file doesn't exist
+            yaml.YAMLError: If the YAML file is invalid
+        """
+        # Setup logger
+        self.logger = loggerplusplus.bind(identifier=self.__class__.__name__)
+
+        # Convert to Path object
+        self.config_path = pathlib.Path(config_path)
+
+        # Validate file exists
+        if not self.config_path.exists():
+            msg = f"Configuration file not found: {self.config_path}"
+            self.logger.error(msg)
+            raise FileNotFoundError(msg)
+
+        # Load the YAML file
+        self._raw_config = self._load_yaml()
+        self.logger.debug(f"Loaded configuration from: {self.config_path}")
+
+        # Call the post-init hook for custom parsing
+        self.__post_init__()
+
+    def _load_yaml(self) -> Dict[str, Any]:
+        """
+        Load and parse the YAML configuration file.
+
+        Returns:
+            Dictionary containing the parsed YAML data
+
+        Raises:
+            yaml.YAMLError: If the YAML file is invalid
+        """
+        try:
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            self.logger.error(f"Failed to parse YAML file: {e}")
+            raise
+
+    def __post_init__(self) -> None:
+        """
+        Hook called after YAML file is loaded.
+
+        Override this method in subclasses to parse the loaded _raw_config
+        and set instance attributes.
+
+        Example:
+            def __post_init__(self) -> None:
+                self.database = DatabaseConfig(**self._raw_config["database"])
+                self.features = [
+                    Feature(**f) for f in self._raw_config["features"]
+                ]
+        """
+        pass
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get a value from the raw config using dot notation.
+
+        Args:
+            key: Key in dot notation (e.g., "database.host")
+            default: Default value if key not found
+
+        Returns:
+            Value from config or default
+
+        Example:
+            >>> config.get("database.host")
+            "localhost"
+
+            >>> config.get("missing.key", default="fallback")
+            "fallback"
+        """
+        keys = key.split(".")
+        value = self._raw_config
+
+        try:
+            for k in keys:
+                value = value[k]
+            return value
+        except (KeyError, TypeError):
+            return default
+
+    def has(self, key: str) -> bool:
+        """
+        Check if a key exists in the raw config using dot notation.
+
+        Args:
+            key: Key in dot notation (e.g., "database.host")
+
+        Returns:
+            True if key exists, False otherwise
+
+        Example:
+            >>> config.has("database.host")
+            True
+
+            >>> config.has("missing.key")
+            False
+        """
+        keys = key.split(".")
+        value = self._raw_config
+
+        try:
+            for k in keys:
+                value = value[k]
+            return True
+        except (KeyError, TypeError):
+            return False
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert config to dictionary, excluding private/special attributes.
+
+        Returns:
+            Dictionary containing all public instance attributes
+        """
+        return {
+            k: v
+            for k, v in self.__dict__.items()
+            if not k.startswith("_") and k not in ("logger", "config_path")
+        }
+
+    def _mask_if_secret(self, key: str, value: Any) -> Any:
+        """
+        Mask potentially sensitive values.
+
+        Args:
+            key: Attribute name
+            value: Attribute value
+
+        Returns:
+            Masked value if sensitive, original value otherwise
+        """
+        if value is None:
+            return None
+
+        key_lower = key.lower()
+        sensitive_keywords = ("secret", "api_key", "password", "token", "credential")
+
+        if any(keyword in key_lower for keyword in sensitive_keywords):
+            s = str(value)
+            if len(s) <= 6:
+                return "***hidden***"
+            return f"{s[:3]}…{s[-2:]} (hidden)"
+
+        return value
+
+    def __repr__(self) -> str:
+        """
+        Pretty representation of the configuration.
+
+        Returns:
+            Formatted string with configuration display
+        """
+        lines = ["\n"]
+        lines.append("╔════════════════════════════════════════════╗")
+        lines.append(f"║  {self.__class__.__name__.upper().center(40)}  ║")
+        lines.append("╚════════════════════════════════════════════╝")
+        lines.append("")
+        lines.append(f"▶ Config Path: {self.config_path}")
+        lines.append("")
+
+        config_dict = self.to_dict()
+        if not config_dict:
+            lines.append("  (No configuration loaded)")
+        else:
+            max_key_len = max(len(k) for k in config_dict.keys())
+
+            for key in sorted(config_dict.keys()):
+                value = config_dict[key]
+                display_value = self._mask_if_secret(key, value)
+
+                # Handle paths
+                if isinstance(display_value, pathlib.Path):
+                    display_value = str(display_value.resolve())
+
+                # Handle lists/dicts - show count
+                if isinstance(display_value, list):
+                    display_value = f"[{len(display_value)} items]"
+                elif isinstance(display_value, dict):
+                    display_value = f"{{{len(display_value)} keys}}"
+
+                lines.append(f"  {key.ljust(max_key_len)} = {display_value!r}")
+
+        lines.append("")
+        return "\n".join(lines)
+
+    def __str__(self) -> str:
+        """String representation uses the pretty repr."""
+        return self.__repr__()

configplusplus-0.1.0.dist-info/METADATA

@@ -0,0 +1,418 @@
+Metadata-Version: 2.4
+Name: configplusplus
+Version: 0.1.0
+Summary: A powerful configuration management library with beautiful display, environment variables and YAML support
+License: MIT
+License-File: LICENSE
+Keywords: config,configuration,environment,yaml,settings
+Author: Florian BARRE
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: loggerplusplus (>=1.0.5)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Project-URL: Documentation, https://github.com/Florian-BARRE/ConfigPlusPlus#readme
+Project-URL: Homepage, https://github.com/Florian-BARRE/ConfigPlusPlus
+Project-URL: Repository, https://github.com/Florian-BARRE/ConfigPlusPlus
+Description-Content-Type: text/markdown
+
+# ConfigPlusPlus
+
+> Beautiful configuration management for Python with environment variables and YAML support
+
+[![PyPI version](https://badge.fury.io/py/configplusplus.svg)](https://pypi.org/project/configplusplus/)
+[![Python](https://img.shields.io/pypi/pyversions/configplusplus.svg)](https://pypi.org/project/configplusplus/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+✨ **Beautiful Display** - Pretty formatted configuration output with automatic grouping and secret masking
+
+🔐 **Secret Masking** - Automatically hides sensitive values (API keys, passwords, tokens)
+
+🌍 **Environment Variables** - Load configuration from environment variables with type casting
+
+📄 **YAML Support** - Load configuration from YAML files with custom parsing
+
+🎯 **Type Casting** - Automatic type conversion (str, int, float, bool, Path)
+
+🏷️ **Static & Instance** - Support for both static class-based and instance-based configs
+
+## Installation
+
+```bash
+pip install configplusplus
+```
+
+Or with Poetry:
+
+```bash
+poetry add configplusplus
+```
+
+## Quick Start
+
+### Environment-Based Configuration
+
+```python
+from configplusplus import EnvConfigLoader, env
+import pathlib
+
+class AppConfig(EnvConfigLoader):
+    # Required variables
+    DATABASE_HOST = env("DATABASE_HOST")
+    DATABASE_PORT = env("DATABASE_PORT", cast=int)
+    
+    # Optional with defaults
+    DEBUG_MODE = env("DEBUG_MODE", cast=bool, default=False)
+    
+    # Paths
+    DATA_DIR = env("DATA_DIR", cast=pathlib.Path)
+    
+    # Secrets (automatically masked in output)
+    SECRET_API_KEY = env("SECRET_API_KEY")
+
+# Use as static class
+print(AppConfig.DATABASE_HOST)
+print(AppConfig)  # Beautiful formatted output
+```
+
+**Output:**
+```
+╔════════════════════════════════════════════╗
+║              APPCONFIG                     ║
+╚════════════════════════════════════════════╝
+
+▶ DATABASE
+    DATABASE_HOST = 'localhost'
+    DATABASE_PORT = 5432
+
+▶ DEBUG
+    DEBUG_MODE = False
+
+▶ DATA
+    DATA_DIR = '/var/data/myapp'
+
+▶ SECRET
+    SECRET_API_KEY = 'sec...et (hidden)'
+```
+
+### YAML-Based Configuration
+
+```python
+from configplusplus import YamlConfigLoader
+
+class UiConfig(YamlConfigLoader):
+    def __post_init__(self) -> None:
+        # Parse the loaded YAML data
+        self.app_name = self._raw_config["application"]["name"]
+        self.theme = self._raw_config["display"]["theme"]
+        
+        # Parse nested structures
+        self.filters = [
+            FilterConfig(**f) 
+            for f in self._raw_config["filters"]
+        ]
+
+# Instantiate with path
+config = UiConfig("config.yaml")
+print(config.app_name)
+print(config)  # Beautiful formatted output
+```
+
+## Environment Variables
+
+### Basic Usage
+
+```python
+from configplusplus import env
+
+# String (default)
+DATABASE_HOST = env("DATABASE_HOST")
+
+# Integer
+DATABASE_PORT = env("DATABASE_PORT", cast=int)
+
+# Boolean
+DEBUG_MODE = env("DEBUG_MODE", cast=bool)
+
+# Float
+TEMPERATURE = env("TEMPERATURE", cast=float)
+
+# Path
+DATA_DIR = env("DATA_DIR", cast=pathlib.Path)
+
+# With default value
+TIMEOUT = env("TIMEOUT", cast=int, default=30)
+
+# Optional (won't raise if missing)
+OPTIONAL = env("OPTIONAL", required=False, default=None)
+```
+
+### Boolean Casting
+
+When `cast=bool`, these strings are considered `False`:
+- `"false"`, `"False"`, `"FALSE"`
+- `"0"`
+- `"no"`, `"No"`, `"NO"`
+- `""` (empty string)
+
+All other values are considered `True`.
+
+### Loading .env Files
+
+```python
+from configplusplus import safe_load_envs
+
+# Load .env file with logging
+safe_load_envs()  # Loads from ".env"
+
+# Load from custom path
+safe_load_envs("config/.env")
+
+# Silent loading
+safe_load_envs(verbose=False)
+```
+
+## YAML Configuration
+
+### Basic Usage
+
+```python
+from configplusplus import YamlConfigLoader
+
+class MyConfig(YamlConfigLoader):
+    def __post_init__(self) -> None:
+        # Access raw YAML data
+        self.database_host = self._raw_config["database"]["host"]
+        self.database_port = self._raw_config["database"]["port"]
+```
+
+### Helper Methods
+
+```python
+config = MyConfig("config.yaml")
+
+# Get values with dot notation
+host = config.get("database.host")
+port = config.get("database.port")
+
+# Get with default
+timeout = config.get("api.timeout", default=30)
+
+# Check if key exists
+if config.has("database.host"):
+    print("Database configured")
+
+# Convert to dictionary
+config_dict = config.to_dict()
+```
+
+## Advanced Features
+
+### Custom Validation
+
+```python
+class ValidatedConfig(EnvConfigLoader):
+    DATABASE_PORT = env("DATABASE_PORT", cast=int)
+    
+    @classmethod
+    def validate(cls) -> None:
+        super().validate()
+        if cls.DATABASE_PORT < 1024:
+            raise RuntimeError("DATABASE_PORT must be >= 1024")
+
+# Validate configuration
+ValidatedConfig.validate()
+```
+
+### Structured Data from YAML
+
+```python
+from dataclasses import dataclass
+from typing import List
+
+@dataclass
+class FilterConfig:
+    name: str
+    type: str
+    enabled: bool = True
+
+class UiConfig(YamlConfigLoader):
+    def __post_init__(self) -> None:
+        # Parse list of structured objects
+        self.filters: List[FilterConfig] = [
+            FilterConfig(**f)
+            for f in self._raw_config["filters"]
+        ]
+```
+
+### Multiple Configuration Sources
+
+```python
+# Combine environment and YAML configs
+class AppConfig(EnvConfigLoader):
+    # From environment
+    SECRET_API_KEY = env("SECRET_API_KEY")
+    DATABASE_HOST = env("DATABASE_HOST")
+    
+    # Load YAML for features
+    @classmethod
+    def load_features(cls) -> None:
+        yaml_config = YamlConfigLoader("features.yaml")
+        cls.FEATURES = yaml_config.get("features")
+
+AppConfig.load_features()
+```
+
+## Secret Masking
+
+Variables containing these keywords are automatically masked in output:
+- `SECRET`
+- `API_KEY`
+- `PASSWORD`
+- `TOKEN`
+- `CREDENTIAL`
+
+Example:
+```python
+SECRET_API_KEY = "sk_live_abc123xyz789"
+# Output: "sk_...89 (hidden)"
+
+PASSWORD = "short"
+# Output: "***hidden***"
+```
+
+## Configuration Grouping
+
+Configuration values are automatically grouped by prefix:
+
+```python
+class AppConfig(EnvConfigLoader):
+    DATABASE_HOST = env("DATABASE_HOST")
+    DATABASE_PORT = env("DATABASE_PORT", cast=int)
+    API_ENDPOINT = env("API_ENDPOINT")
+    API_KEY = env("API_KEY")
+```
+
+**Output shows grouped display:**
+```
+▶ DATABASE
+    DATABASE_HOST = 'localhost'
+    DATABASE_PORT = 5432
+
+▶ API
+    API_ENDPOINT = 'https://api.example.com'
+    API_KEY = 'key...23 (hidden)'
+```
+
+## Real-World Examples
+
+### FastAPI Application Config
+
+```python
+from configplusplus import EnvConfigLoader, env, safe_load_envs
+import pathlib
+
+safe_load_envs()
+
+class APIConfig(EnvConfigLoader):
+    # Server
+    HOST = env("HOST", default="0.0.0.0")
+    PORT = env("PORT", cast=int, default=8000)
+    
+    # Database
+    DATABASE_URL = env("DATABASE_URL")
+    DATABASE_POOL_SIZE = env("DATABASE_POOL_SIZE", cast=int, default=10)
+    
+    # Redis
+    REDIS_HOST = env("REDIS_HOST", default="localhost")
+    REDIS_PORT = env("REDIS_PORT", cast=int, default=6379)
+    
+    # Security
+    SECRET_JWT_KEY = env("SECRET_JWT_KEY")
+    TOKEN_EXPIRE_MINUTES = env("TOKEN_EXPIRE_MINUTES", cast=int, default=60)
+    
+    # Features
+    ENABLE_CORS = env("ENABLE_CORS", cast=bool, default=True)
+    ENABLE_DOCS = env("ENABLE_DOCS", cast=bool, default=False)
+    
+    @classmethod
+    def validate(cls) -> None:
+        if cls.PORT < 1024 or cls.PORT > 65535:
+            raise RuntimeError("Invalid PORT")
+
+# Use in FastAPI
+from fastapi import FastAPI
+
+app = FastAPI(
+    title="My API",
+    docs_url="/docs" if APIConfig.ENABLE_DOCS else None,
+)
+```
+
+### Document Processing Pipeline Config
+
+```python
+from configplusplus import YamlConfigLoader
+from typing import List
+from dataclasses import dataclass
+
+@dataclass
+class ProcessorConfig:
+    name: str
+    enabled: bool
+    priority: int
+
+class PipelineConfig(YamlConfigLoader):
+    def __post_init__(self) -> None:
+        # Parse processors
+        self.processors: List[ProcessorConfig] = [
+            ProcessorConfig(**p)
+            for p in self._raw_config["processors"]
+        ]
+        
+        # Parse paths
+        self.input_dir = pathlib.Path(self._raw_config["paths"]["input"])
+        self.output_dir = pathlib.Path(self._raw_config["paths"]["output"])
+        
+        # Parse settings
+        self.batch_size = self._raw_config["settings"]["batch_size"]
+        self.max_workers = self._raw_config["settings"]["max_workers"]
+
+# Load configuration
+config = PipelineConfig("pipeline.yaml")
+
+# Use in pipeline
+for processor in sorted(config.processors, key=lambda x: x.priority):
+    if processor.enabled:
+        print(f"Running {processor.name}")
+```
+
+## Documentation
+
+- **Quick Reference**: See [REFERENCE.md](REFERENCE.md) for a cheat sheet
+- **Detailed Guide**: See [USAGE.md](USAGE.md) for comprehensive documentation
+- **Examples**: Check the `examples/` directory for working code samples
+
+## Links
+
+- **PyPI**: https://pypi.org/project/configplusplus/
+- **GitHub**: https://github.com/Florian-BARRE/ConfigPlusPlus
+- **Issues**: https://github.com/Florian-BARRE/ConfigPlusPlus/issues
+
+## License
+
+MIT License - See [LICENSE](LICENSE) file for details.
+
+**Author**: Florian BARRE
+

configplusplus-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+configplusplus/__init__.py,sha256=X0kpTKmnieSUJGAteRcqc9ALIyN-YZH6060vnKvCboM,473
+configplusplus/base.py,sha256=t4pFLrwRefdMVQjQRfsslgxvZcupRQ8HOeYC1P3vm-U,4317
+configplusplus/env_loader.py,sha256=yFgZs0Rk93m4Ai8VwjlmS84DMxll61FR0ywwHNLx-CU,3846
+configplusplus/utils.py,sha256=-G_GmsF2wij66cmHAZPrPGErffVyaqO0jkfm3haU5JE,3363
+configplusplus/yaml_loader.py,sha256=HSATQWmUzi2K20ZfV-AkvT5MY84A1WUqcKIizJSvWhc,7907
+configplusplus-0.1.0.dist-info/METADATA,sha256=hBBVJ3E5oHShrmUdT5ZztoK0vXzgeRKYdVTsmR9iK2U,10658
+configplusplus-0.1.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+configplusplus-0.1.0.dist-info/licenses/LICENSE,sha256=DalX5FRVQEaFnrjMMLLqNh2NAUk3ZHHjA_uAE7JdIlk,1070
+configplusplus-0.1.0.dist-info/RECORD,,

configplusplus-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.0
+Root-Is-Purelib: true
+Tag: py3-none-any

configplusplus-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Florian BARRE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.