tessl/pypi-django-dynamic-preferences
Dynamic global and instance settings for your django project
—
Pending
core-models.mddocs/
Core Models and Managers
Database models for storing preferences and manager classes for cached preference access with automatic synchronization. These components form the foundation of the dynamic preferences system.
Capabilities
Base Preference Model
Abstract Django model that provides common functionality for all preference models, including value serialization and preference metadata access.
class BasePreferenceModel(models.Model):
"""
Abstract base model for all preference models.
Fields:
- section (CharField): The section under which the preference is declared
- name (CharField): A name for the preference
- raw_value (TextField): Serialized value (should not be accessed directly)
"""
section = models.CharField(max_length=150)
name = models.CharField(max_length=150)
raw_value = models.TextField()
@property
def preference(self):
"""Returns the preference object from registry."""
@property
def verbose_name(self) -> str:
"""Returns preference verbose name."""
@property
def help_text(self) -> str:
"""Returns preference help text."""
@property
def value(self):
"""Gets/sets deserialized preference value."""
@value.setter
def value(self, value):
"""Sets the preference value with automatic serialization."""
def set_value(self, value):
"""Save serialized value to raw_value field."""
def get_value(self):
"""Return deserialized raw_value."""
def save(self, **kwargs):
"""Override to set default value if needed."""Global Preference Model
Concrete Django model for storing global (site-wide) preferences.
class GlobalPreferenceModel(BasePreferenceModel):
"""
Model for global preferences (site-wide settings).
Meta:
- unique_together = ("section", "name")
"""
class Meta:
unique_together = ("section", "name")Per Instance Preference Model
Abstract Django model for preferences tied to specific model instances (e.g., user-specific preferences).
class PerInstancePreferenceModel(BasePreferenceModel):
"""
Abstract base for preferences tied to specific model instances.
Fields:
- instance (ForeignKey): The instance concerned by the preference (must be defined in subclass)
"""
@classmethod
def get_instance_model(cls):
"""Returns the model class for the instance field."""Preferences Manager
Manager class that handles preference retrieval, caching, and database synchronization. Implements Mapping interface for dict-like access.
class PreferencesManager:
"""
Handle retrieving/caching of preferences.
Args:
- model: The preference model class
- registry: The preference registry
- **kwargs: Additional options (instance, etc.)
"""
def __init__(self, model, registry, **kwargs):
"""Initialize with model and registry."""
def __getitem__(self, key: str):
"""Get preference value by key (section__name format)."""
def __setitem__(self, key: str, value):
"""Set preference value by key."""
def get(self, key: str, no_cache: bool = False):
"""
Return preference value with optional cache bypass.
Args:
- key: Preference identifier (section__name)
- no_cache: If True, bypass cache and load from database
Returns:
Preference value
"""
def all(self) -> dict:
"""Return dictionary of all preferences organized by section."""
def by_name(self) -> dict:
"""Return dict with preferences without section in identifier."""
def get_by_name(self, name: str):
"""Get preference by name only (without section)."""
def update_db_pref(self, section: str, name: str, value):
"""Update preference in database."""
def create_db_pref(self, section: str, name: str, value):
"""Create new preference in database."""
def load_from_db(self, cache: bool = False):
"""Load preferences directly from database."""
@property
def queryset(self):
"""Model queryset (filtered by instance if applicable)."""
@property
def cache(self):
"""Django cache backend."""Usage Examples
Basic Preference Access
from dynamic_preferences.registries import global_preferences_registry
# Get manager instance
global_preferences = global_preferences_registry.manager()
# Get preference value
site_title = global_preferences['general__title']
# Set preference value
global_preferences['general__maintenance_mode'] = True
# Get all preferences
all_prefs = global_preferences.all()
# Returns: {'general': {'title': 'My Site', 'maintenance_mode': True}, ...}Cache Management
# Bypass cache for fresh database value
fresh_value = global_preferences.get('general__title', no_cache=True)
# Reload all preferences from database
global_preferences.load_from_db()Working with Sections
# Get preferences organized by section
preferences_by_section = global_preferences.all()
# Get preferences without section prefixes
preferences_by_name = global_preferences.by_name()
# Returns: {'title': 'My Site', 'maintenance_mode': True, ...}
# Get preference by name only (if unique)
title = global_preferences.get_by_name('title')Install with Tessl CLI
npx tessl i tessl/pypi-django-dynamic-preferences