Configuration Manager with Lifecycle Hooks

Build a configuration management system that loads settings from dictionaries and provides lifecycle hooks for validation and setup. The system should support inheritance, avoid unnecessary object recreation, and maintain proper type signatures for IDE support.

Requirements

Configuration Base Class

Create a ConfigManager class that:

• Accepts a dictionary of settings in its constructor
• Stores settings as instance attributes
• Automatically calls setup logic before initialization
• Automatically calls validation logic after initialization
• Maintains proper function signature despite custom object creation

Validated Configuration Manager

Create a ValidatedConfigManager class that:

• Accepts settings dict and required_keys list in constructor
• Stores settings as instance attributes
• Validates that all required keys are present in settings after initialization
• Returns the same object instance when passed to its own constructor with no additional arguments
• Maintains proper function signature despite custom object creation

Test Cases

• Creating a ConfigManager with settings {"host": "localhost", "port": 8080} stores both as attributes @test
• ValidatedConfigManager with settings {"api_key": "secret", "db_host": "localhost"} and required_keys ["api_key", "db_host"] validates successfully @test
• ValidatedConfigManager with settings {"api_key": "secret"} and required_keys ["api_key", "db_host"] raises validation error during initialization @test
• Passing an existing ValidatedConfigManager instance to the constructor returns the same object (identity check) @test

@generates

API

class ConfigManager:
    """
    Base configuration manager with lifecycle hooks.

    Automatically calls _setup() before __init__ and _validate() after __init__.
    Maintains proper signature for IDE support despite custom __new__.
    """

    def __init__(self, settings: dict):
        """
        Initialize configuration manager.

        Args:
            settings: Dictionary of configuration key-value pairs
        """
        pass

    def _setup(self):
        """Called before __init__. Override for setup logic."""
        pass

    def _validate(self):
        """Called after __init__. Override for validation logic."""
        pass

    def __new__(cls, *args, **kwargs):
        """Custom object creation."""
        pass


class ValidatedConfigManager:
    """
    Configuration manager with required key validation.

    Validates that required keys are present in settings. Maintains
    proper signature. Avoids recreating existing instances.
    """

    def __init__(self, settings: dict, required_keys: list):
        """
        Initialize with required keys for validation.

        Args:
            settings: Dictionary of configuration key-value pairs
            required_keys: List of keys that must be present in settings
        """
        pass

    def __new__(cls, *args, **kwargs):
        """Custom object creation to avoid recreating existing instances."""
        pass

Dependencies { .dependencies }

fastcore { .dependency }

Provides metaprogramming utilities including metaclasses for enhanced class behavior.