tessl/pypi-dynaconf

The dynamic configurator for your Python Project

—

Pending

Overview

Eval results

Files

Framework Integration

Name: tessl/pypi-dynaconf
Author: tessl

Native integration with Flask and Django frameworks providing seamless configuration management for web applications with automatic settings binding and framework-specific optimizations. These integrations enable dynaconf to work naturally within existing web application architectures.

Capabilities

Flask Integration

Integrate dynaconf with Flask applications for automatic configuration management.

class FlaskDynaconf:
    """Flask extension for dynaconf integration."""
    def __init__(
        self,
        app=None,                           # Flask application instance
        instance_relative_config=False,     # Use instance-relative config
        dynaconf_instance=None,             # Existing dynaconf instance
        extensions_list=False,              # Enable extensions list
        **kwargs                            # Additional dynaconf options
    ): ...
    
    def init_app(self, app, **kwargs):
        """Initialize the extension with Flask app."""
        ...
    
    def make_config(self, app):
        """Create configuration object for Flask app."""
        ...

class DynaconfConfig:
    """Configuration object that integrates dynaconf with Flask's config system."""
    def __init__(self, _settings, _app, *args, **kwargs): ...
    
    def get(self, key, default=None):
        """Get configuration value."""
        ...
    
    def load_extensions(self, key="EXTENSIONS", app=None):
        """Load Flask extensions dynamically."""
        ...
    
    # Standard dict methods
    def keys(self): ...
    def values(self): ...
    def items(self): ...
    def setdefault(self, key, default): ...

Usage examples:

from flask import Flask
from dynaconf import FlaskDynaconf

# Method 1: Direct initialization
app = Flask(__name__)
FlaskDynaconf(app)

# Method 2: Factory pattern
app = Flask(__name__)
dynaconf = FlaskDynaconf()
dynaconf.init_app(app)

# Method 3: With custom settings
app = Flask(__name__)
FlaskDynaconf(
    app,
    envvar_prefix="MYAPP",
    settings_files=["config.toml", "local.yaml"],
    environments=True
)

# Access settings through Flask's config
@app.route("/")
def index():
    debug_mode = app.config.DEBUG
    database_url = app.config.DATABASE_URL
    return f"Debug: {debug_mode}, DB: {database_url}"

Django Integration

Integrate dynaconf with Django applications for dynamic settings management.

def DjangoDynaconf(settings_module):
    """
    Configure Django to use dynaconf for settings management.
    
    Args:
        settings_module (str): Django settings module name
        
    Returns:
        LazySettings: Configured dynaconf instance for Django
    """
    ...

Usage examples:

# In Django settings.py
import dynaconf

# Replace Django's default settings with dynaconf
settings = dynaconf.DjangoDynaconf(__name__)

# The settings object works like Django's normal settings
DEBUG = settings.DEBUG
DATABASES = settings.DATABASES
SECRET_KEY = settings.SECRET_KEY

# Environment-based configuration
if settings.current_env == "production":
    ALLOWED_HOSTS = settings.ALLOWED_HOSTS
else:
    ALLOWED_HOSTS = ["localhost", "127.0.0.1"]

Framework-Specific Patterns

Flask Application Factory

Configure dynaconf in Flask application factories.

from flask import Flask
from dynaconf import FlaskDynaconf

def create_app(config_name=None):
    """Application factory with dynaconf integration."""
    app = Flask(__name__)
    
    # Configure dynaconf with environment-specific settings
    FlaskDynaconf(
        app,
        envvar_prefix="MYAPP",
        settings_files=[
            "config/default.toml",
            f"config/{config_name or 'development'}.toml"
        ],
        environments=True,
        load_dotenv=True
    )
    
    # Register blueprints
    from .views import main
    app.register_blueprint(main)
    
    return app

# Usage
app = create_app("production")

Django Multi-Environment Setup

Configure Django for multiple environments with dynaconf.

# settings/__init__.py
import os
import dynaconf

# Determine environment from ENV variable or default to development
environment = os.environ.get("DJANGO_ENV", "development")

# Configure dynaconf for Django
settings = dynaconf.DjangoDynaconf(
    __name__,
    envvar_prefix="DJANGO",
    settings_files=[
        "config/base.toml",
        f"config/{environment}.toml",
        ".secrets.toml"
    ],
    environments=True,
    env_switcher="DJANGO_ENV",
    load_dotenv=True
)

# Base Django settings
BASE_DIR = settings.BASE_DIR
SECRET_KEY = settings.SECRET_KEY
DEBUG = settings.DEBUG

# Database configuration from dynaconf
DATABASES = {
    "default": {
        "ENGINE": settings.DB_ENGINE,
        "NAME": settings.DB_NAME,
        "USER": settings.DB_USER,
        "PASSWORD": settings.DB_PASSWORD,
        "HOST": settings.DB_HOST,
        "PORT": settings.DB_PORT,
    }
}

# Framework-specific settings
INSTALLED_APPS = settings.INSTALLED_APPS
MIDDLEWARE = settings.MIDDLEWARE
ROOT_URLCONF = settings.ROOT_URLCONF

Flask Configuration Classes

Use dynaconf with Flask configuration classes.

from dynaconf import Dynaconf

class Config:
    """Base configuration using dynaconf."""
    
    def __init__(self):
        self.settings = Dynaconf(
            envvar_prefix="FLASK",
            settings_files=["config.toml"],
            environments=True,
            load_dotenv=True
        )
    
    # Map dynaconf settings to Flask config attributes
    @property
    def SECRET_KEY(self):
        return self.settings.SECRET_KEY
    
    @property
    def SQLALCHEMY_DATABASE_URI(self):
        return self.settings.DATABASE_URL
    
    @property
    def SQLALCHEMY_TRACK_MODIFICATIONS(self):
        return self.settings.get("SQLALCHEMY_TRACK_MODIFICATIONS", False)

class DevelopmentConfig(Config):
    """Development configuration."""
    
    def __init__(self):
        super().__init__()
        self.settings.setenv("development")

class ProductionConfig(Config):
    """Production configuration."""
    
    def __init__(self):
        super().__init__()
        self.settings.setenv("production")

# Application factory using config classes
def create_app(config_name):
    app = Flask(__name__)
    
    config_classes = {
        "development": DevelopmentConfig,
        "production": ProductionConfig
    }
    
    config = config_classes[config_name]()
    app.config.from_object(config)
    
    return app

Django Custom Settings Management

Advanced Django integration with custom settings management.

# settings/dynaconf_settings.py
import dynaconf
from dynaconf import Validator

# Custom validators for Django settings
django_validators = [
    Validator("SECRET_KEY", must_exist=True, len_min=50),
    Validator("DEBUG", cast=bool, default=False),
    Validator("ALLOWED_HOSTS", cast=list, default=[]),
    Validator("DATABASE_URL", must_exist=True),
    
    # Environment-specific validators
    Validator("DEBUG", eq=False, env="production"),
    Validator("ALLOWED_HOSTS", len_min=1, env="production"),
]

# Configure dynaconf with validation
settings = dynaconf.DjangoDynaconf(
    __name__,
    envvar_prefix="DJANGO",
    settings_files=[
        "config/django.toml",
        "config/local.toml"
    ],
    environments=True,
    validators=django_validators,
    load_dotenv=True
)

# Validate settings on load
try:
    settings.validators.validate()
except dynaconf.ValidationError as e:
    print(f"Django settings validation failed: {e}")
    raise

# Django-specific settings mapping
DEBUG = settings.DEBUG
SECRET_KEY = settings.SECRET_KEY
ALLOWED_HOSTS = settings.ALLOWED_HOSTS

# Database configuration
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": settings.get("DB_NAME", "myapp"),
        "USER": settings.get("DB_USER", "postgres"),
        "PASSWORD": settings.DB_PASSWORD,
        "HOST": settings.get("DB_HOST", "localhost"),
        "PORT": settings.get("DB_PORT", 5432),
    }
}

# Application definition
INSTALLED_APPS = settings.get("INSTALLED_APPS", [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
])

Best Practices

Flask Best Practices

# Use environment-specific configuration files
FlaskDynaconf(
    app,
    settings_files=[
        "config/base.toml",        # Base configuration
        "config/{env}.toml",       # Environment-specific
        ".secrets.toml"            # Sensitive data
    ],
    environments=True,
    load_dotenv=True
)

# Access configuration through Flask's app.config
def get_database_config():
    return {
        "host": app.config.DB_HOST,
        "port": app.config.DB_PORT,
        "database": app.config.DB_NAME
    }

Django Best Practices

# Separate settings by environment
# settings/base.py - Common settings
# settings/development.py - Development overrides  
# settings/production.py - Production overrides

# Use validation for critical settings
validators = [
    Validator("SECRET_KEY", must_exist=True),
    Validator("DATABASES", must_exist=True),
    Validator("ALLOWED_HOSTS", must_exist=True, env="production")
]

settings = dynaconf.DjangoDynaconf(
    __name__,
    validators=validators
)

Testing Integration

# Flask testing with dynaconf
def test_app_with_test_config():
    app = create_app()
    
    # Override configuration for testing
    app.config.update({
        "TESTING": True,
        "DATABASE_URL": "sqlite:///:memory:"
    })
    
    with app.test_client() as client:
        response = client.get("/")
        assert response.status_code == 200

# Django testing with dynaconf
# In Django test settings
import dynaconf

settings = dynaconf.DjangoDynaconf(
    __name__,
    envvar_prefix="DJANGO_TEST",
    settings_files=["config/test.toml"],
    force_env="testing"
)

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": ":memory:"
    }
}

Install with Tessl CLI