Skip to content

0.4.0
Compare
Choose a tag to compare
@igorbenav igorbenav released this 24 Jun 06:57
· 21 commits to main since this release
v0.4.0
1c189b1

CRUDAdmin v0.4.0 - Session Configuration API Overhaul

🚨 BREAKING CHANGES - Migration Required

This release introduces a complete overhaul of the session backend configuration API, replacing the old method-based approach with a cleaner constructor-based system. All existing code using session backends will need to be updated.

⚠️ Removed Session Methods

The following session configuration methods have been removed and will cause errors if used:

# ❌ REMOVED - These methods no longer exist:
admin.use_redis_sessions(...)
admin.use_memcached_sessions(...)
admin.use_memory_sessions(...)
admin.use_database_sessions(...)
admin._recreate_session_manager()

🔄 Required Migration Steps

Before (v0.3.x):

from crudadmin import CRUDAdmin

# Old method-based Redis configuration - WILL NOT WORK in v0.4.0+
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="your-secret-key",
    # Basic setup first
)

# ❌ Old method calls that no longer work
admin.use_redis_sessions(
    host="localhost",
    port=6379,
    db=0,
    password="mypassword",
    pool_size=20,
    connect_timeout=10
)

# Old Memcached method - WILL NOT WORK in v0.4.0+
admin.use_memcached_sessions(
    servers=["localhost:11211"],
    pool_size=10
)

After (v0.4.0+):

from crudadmin import CRUDAdmin
from crudadmin.session.configs import RedisConfig, MemcachedConfig

# ✅ Method 1: Using configuration objects (recommended)
redis_config = RedisConfig(
    host="localhost",
    port=6379,
    db=0,
    password="mypassword",
    pool_size=20,
    connect_timeout=10
)

admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="your-secret-key",
    session_backend="redis",
    redis_config=redis_config
)

# ✅ Method 2: Using dictionary configuration
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="your-secret-key",
    session_backend="redis",
    redis_config={
        "host": "localhost",
        "port": 6379,
        "db": 0,
        "password": "mypassword",
        "pool_size": 20,
        "connect_timeout": 10
    }
)

# ✅ Method 3: Using Redis URL
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="your-secret-key",
    session_backend="redis",
    redis_config={"url": "redis://:mypassword@localhost:6379/0"}
)

# ✅ New Memcached configuration
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="your-secret-key",
    session_backend="memcached",
    memcached_config={
        "servers": ["localhost:11211"],
        "pool_size": 10
    }
)

✨ New Features

🗂️ New Configuration Module

  • New module: crudadmin.session.configs with configuration classes:
    • RedisConfig - Redis backend configuration with URL parsing and validation
    • MemcachedConfig - Memcached backend configuration with server list support

🔧 Constructor-Based Session Configuration

  • Direct configuration: All session backends now configured directly in the constructor
  • No method chaining: Eliminates timing issues and complexity from the old method-based approach
  • Type safety: Full Pydantic validation for all configuration parameters
  • Flexible formats: Support for configuration objects, dictionaries, and URLs
# All these formats are now supported:
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key",
    session_backend="redis",
    redis_config=RedisConfig(url="redis://user:pass@host:6379/1")
)

admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key", 
    session_backend="redis",
    redis_config={"host": "localhost", "port": 6379, "db": 0}
)

📊 Enhanced Redis Configuration

  • URL parsing: Full Redis URL support with automatic parameter extraction
  • Connection validation: Pydantic validation for all Redis parameters
  • Connection pooling: Proper connection pool size and timeout configuration
  • ACL support: Full Redis 6.0+ ACL username/password authentication

🔗 Enhanced Memcached Configuration

  • Server list support: Configure multiple Memcached servers
  • Connection pooling: Configurable pool sizes for better performance
  • Validation: Automatic validation of server addresses and ports

🎯 Simplified API

  • No method chaining: All configuration done at construction time
  • Better error handling: Configuration errors caught immediately at startup
  • Cleaner code: No need for manual session manager recreation
  • Documentation: Enhanced docstrings with configuration examples

🐛 Bug Fixes

🔧 API Consistency & Reliability

  • Eliminated method chaining issues: No more timing problems with session backend configuration
  • Removed race conditions: Session backends are now configured atomically at construction
  • Better error messages: Clear validation errors when configuration is invalid
  • Lazy dependency loading: Optional dependencies (redis, memcached) only loaded when needed

🧪 Test Suite Improvements

  • Fixed all failing tests related to the API changes
  • Updated test patterns: All tests now use new constructor-based configuration
  • Better test coverage: Added tests for configuration validation and edge cases
  • Maintained compatibility: All existing functionality preserved

🚀 Improvements

📚 Better Documentation

  • Updated examples: All code examples use new configuration format
  • Migration guide: Clear upgrade path from v0.3.x to v0.4.0
  • Configuration reference: Comprehensive documentation for all config options
  • Type hints: Improved type annotations throughout

🏗️ Code Organization

  • Separation of concerns: Configuration logic moved to dedicated module
  • Maintainability: Easier to extend with new session backends
  • Validation: Centralized parameter validation with clear error messages
  • Extensibility: Simple to add new configuration options

📋 Technical Details

Dependencies

  • No new dependencies added
  • Pydantic 2.0+ (existing requirement) used for configuration validation
  • Backward compatible with existing optional dependencies (redis, memcached)

Python Support

  • Python 3.9+ (unchanged)
  • Tested on Python 3.9, 3.10, 3.11, 3.12

Performance

  • ✅ No performance impact - same underlying session backends
  • ✅ Improved validation prevents configuration errors at startup
  • ✅ Better connection pooling configuration options

🔍 Full Changelog

Added

  • crudadmin.session.configs module with RedisConfig and MemcachedConfig classes
  • redis_config parameter to CRUDAdmin constructor
  • memcached_config parameter to CRUDAdmin constructor
  • Constructor-based session backend configuration (replaces method-based approach)
  • URL parsing support for Redis connections
  • Multiple server support for Memcached
  • Pydantic validation for all configuration parameters
  • Support for dictionary-based configuration alongside config objects
  • redis_pool_size and redis_connect_timeout parameters
  • memcached_pool_size parameter

Changed

  • BREAKING: Session backend configuration moved from methods to constructor parameters
  • BREAKING: All session configuration now happens at construction time
  • Enhanced constructor docstring with comprehensive configuration examples
  • Improved error handling and validation for session configurations
  • Better lazy loading of optional dependencies

Removed

  • BREAKING: admin.use_redis_sessions() method
  • BREAKING: admin.use_memcached_sessions() method
  • BREAKING: admin.use_memory_sessions() method
  • BREAKING: admin.use_database_sessions() method
  • BREAKING: admin._recreate_session_manager() method
  • Method chaining complexity and associated timing issues

Fixed

  • Session backend initialization race conditions
  • Method chaining timing issues that could cause configuration failures
  • Test suite compatibility with new constructor-based API
  • Lazy loading of optional Redis and Memcached dependencies
  • Configuration validation and error messages

📖 Upgrade Guide

Quick Migration Checklist

  1. ✅ Remove old method calls: Delete all admin.use_*_sessions() method calls
  2. ✅ Add session configuration to constructor: Move session config to CRUDAdmin() constructor
  3. ✅ Update imports (if using config objects): 
    from crudadmin.session.configs import RedisConfig, MemcachedConfig
  4. ✅ Choose configuration format: Use config objects, dictionaries, or URLs
  5. ✅ Test your configuration: Validation happens immediately at startup
  6. ✅ Update documentation: Update any internal documentation/deployment scripts

Migration Examples

Simple Redis Migration

# Before v0.4.0
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key"
)
admin.use_redis_sessions(
    host="localhost",
    port=6379,
    db=0
)

# After v0.4.0
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key",
    session_backend="redis",
    redis_config={"host": "localhost", "port": 6379, "db": 0}
)

Redis with Advanced Configuration

# Before v0.4.0
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key"
)
admin.use_redis_sessions(
    url="redis://user:[email protected]:6379/1",
    pool_size=20,
    connect_timeout=10
)

# After v0.4.0 - Option 1: Using config object
from crudadmin.session.configs import RedisConfig

redis_config = RedisConfig(
    url="redis://user:[email protected]:6379/1",
    pool_size=20,
    connect_timeout=10
)
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key",
    session_backend="redis",
    redis_config=redis_config
)

# After v0.4.0 - Option 2: Using dictionary
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key",
    session_backend="redis",
    redis_config={
        "url": "redis://user:[email protected]:6379/1",
        "pool_size": 20,
        "connect_timeout": 10
    }
)

Memcached Migration

# Before v0.4.0
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key"
)
admin.use_memcached_sessions(
    servers=["localhost:11211"],
    pool_size=10
)

# After v0.4.0
admin = CRUDAdmin(
    session=get_session,
    SECRET_KEY="key",
    session_backend="memcached",
    memcached_config={
        "servers": ["localhost:11211"], 
        "pool_size": 10
    }
)

Need Help?

This release focused on eliminating the complexity and timing issues of the old method-based session configuration while providing a cleaner, more reliable constructor-based API. The new system eliminates race conditions, provides better type safety, and makes session configuration more predictable and easier to debug.

This is a breaking change release - please test thoroughly before upgrading production environments and follow the migration guide above.

🔗 Links

Assets 2
Loading