configurator/README.md

# Configurator

`configurator` is a Python package designed for efficient and standardized configuration management in your
applications. It uses a singleton pattern to ensure that configuration is loaded once and accessible throughout your
application. It supports merging custom configurations, validation of required configurations, and ease of access
through getter methods.

## Features

- Singleton pattern for configuration management
- Support for loading and merging custom configurations
- Simple validation for required configuration variables
- Easily extendable for additional configuration sources

## Installation

You can install the package via pip:

```bash
pip install --index-url https://git.juggalol.com/api/packages/juggalol/pypi/simple configurator
```

Or by cloning this repository and installing with:

```bash
git clone https://github.com/juggalol/configurator.git
cd configurator
pip install .
```

## Usage

### Initial Setup

To use `configurator` in your application, you first need to load the configuration. This should typically be done once
at the start of your application, for instance, in the main entry point or the initial setup script.

```python
from configurator import load_config, get_config, ConfigurationError

# Define custom configuration for the application
custom_config = {
    'DATABASE_URL': 'sqlite:///default.db',
    'SECRET_KEY': 'defaultsecretkey',
}

def main():
    try:
        # Load configuration with custom settings
        load_config(custom_config=custom_config)
        
        # Example usage of get_config
        database_url = get_config('DATABASE_URL')
        print(f"Database URL: {database_url}")

        # Example usage of another config variable
        secret_key = get_config('SECRET_KEY')
        print(f"Secret Key: {secret_key}")
    except ConfigurationError as e:
        print(f"Failed to load configuration: {e}")
        exit(1)

if __name__ == "__main__":
    main()

```

### Accessing Configuration Values

You can access configuration values using the `get_config` function. If the key does not exist, you can provide a
default value.

```python
from configurator import get_config

log_level = get_config('LOG_LEVEL', 'INFO')
print(f"Log Level: {log_level}")

debug_mode = get_config('DEBUG', False)
print(f"Debug Mode: {debug_mode}")
```

### Configuration Validation

The package includes basic validation to ensure that all required configurations are provided. If a required variable is
missing, a `ConfigurationError` will be raised.

You can customize validation requirements in the `validators` module if needed.

## Custom Configuration

Custom configurations can be passed to the `load_config` function. These will be merged with the default configurations
provided in the environment or settings files.

Example:

```python
custom_config = {
    'API_ENDPOINT': 'https://api.example.com',
    'TIMEOUT': 30,
}
load_config(custom_config)
api_endpoint = get_config('API_ENDPOINT')
print(f"API Endpoint: {api_endpoint}")
```

## Extending Configurator

You can extend the `Configurator` to support additional configuration sources like JSON files, remote configuration
services, etc. This would typically involve modifying the `load_config` function.

```python
def load_config(custom_config=None, json_file=None) -> dict:
    global _config_values
    if _config_values is None:
        default_config = {
            'LOG_LEVEL': config('LOG_LEVEL', default='INFO'),
            'DEBUG': config('DEBUG', default='false', cast=bool),
            'ENV': config('ENV', default='DEV')
        }

        if json_file:
            with open(json_file, 'r') as jf:
                json_config = json.load(jf)
                default_config.update(json_config)

        # Merge custom config if present
        if custom_config:
            default_config.update(custom_config)

        config_values = {key: config(key, default=value) for key, value in default_config.items()}

        required_vars = [key for key, value in default_config.items() if value is None]
        validate_config(config_values, required_vars)

        _config_values = config_values
    
    return _config_values
```

## Contributing

Contributions are welcome! Please fork the repository and submit a pull request with your changes. For major changes,
please open an issue first to discuss what you would like to change.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.