Configuration Management

class Configuration:
    def __init__(self, appname, modname=None, read=True, loader=yaml_util.Loader):
        """
        Create a configuration object for an application.
        
        Parameters:
        - appname (str): Name of the application for config directory/file naming
        - modname (str, optional): Module name for finding package defaults
        - read (bool): Whether to automatically read config files on creation
        - loader: YAML loader class for parsing configuration files
        """
    
    def config_dir(self):
        """
        Get the configuration directory path for this application.
        
        Returns:
        str: Platform-specific configuration directory path
        """
    
    def user_config_path(self):
        """
        Get the path to the user's configuration file.
        
        Returns:
        str: Path to user configuration file (config.yaml)
        """
    
    def read(self, user=True, defaults=True):
        """
        Read configuration from files.
        
        Parameters:
        - user (bool): Whether to read user configuration file
        - defaults (bool): Whether to read package default configuration
        """
    
    def set_file(self, filename, base_for_paths=False):
        """
        Add a YAML configuration file as a source.
        
        Parameters:
        - filename (str): Path to YAML configuration file
        - base_for_paths (bool): Use file's directory as base for relative paths
        """
    
    def set_env(self, prefix=None, sep='__'):
        """
        Add environment variables as a configuration source.
        
        Parameters:
        - prefix (str, optional): Environment variable prefix (defaults to appname)
        - sep (str): Separator for nested keys in variable names
        """
    
    def dump(self, full=True, redact=False):
        """
        Generate YAML representation of current configuration.
        
        Parameters:
        - full (bool): Include all configuration sources
        - redact (bool): Hide sensitive values
        
        Returns:
        str: YAML representation of configuration
        """
    
    def reload(self):
        """
        Reload configuration from all file sources.
        """

class LazyConfig(Configuration):
    def __init__(self, appname, modname=None):
        """
        Create a lazy-loading configuration object.
        
        Parameters:
        - appname (str): Name of the application
        - modname (str, optional): Module name for package defaults
        """

class RootView:
    def __init__(self, sources):
        """
        Create a root view managing configuration sources.
        
        Parameters:
        - sources: List of ConfigSource objects in priority order
        """
    
    def add(self, obj):
        """
        Add a configuration source as the lowest priority.
        
        Parameters:
        - obj: Configuration data (dict, ConfigSource, or convertible type)
        """
    
    def set(self, value):
        """
        Override configuration values with highest priority.
        
        Parameters:
        - value: Configuration data to overlay
        """
    
    def clear(self):
        """
        Remove all configuration sources.
        """

import confuse

# Create configuration for "myapp"
config = confuse.Configuration('myapp')

# Configuration files will be looked for in:
# - ~/.config/myapp/config.yaml (Linux/Unix)
# - ~/Library/Application Support/myapp/config.yaml (macOS)  
# - %APPDATA%\\myapp\\config.yaml (Windows)

print(f"Config directory: {config.config_dir()}")
print(f"User config file: {config.user_config_path()}")

import confuse

# Create configuration without auto-reading
config = confuse.Configuration('myapp', read=False)

# Add specific configuration file
config.set_file('/etc/myapp/system.yaml')

# Add user configuration
config.read(user=True, defaults=False)

# Add environment variables with MYAPP_ prefix
config.set_env('MYAPP_')

# Add runtime overrides
config.set({'debug': True, 'log_level': 'DEBUG'})

import confuse

# Configuration files won't be read until first access
lazy_config = confuse.LazyConfig('myapp')

# Files are read when first configuration value is accessed
debug_mode = lazy_config['debug'].get(bool)

import confuse

config = confuse.Configuration('myapp')
config.set({'secret_key': 'sensitive_value'})

# Dump all configuration (including sensitive values)
full_config = config.dump(full=True, redact=False)

# Dump with sensitive values redacted
safe_config = config.dump(full=True, redact=True)

print("Full config:")
print(full_config)
print("\\nRedacted config:")
print(safe_config)