I'm working on a Django project and encountering an issue with Django views. Here's my current implementation:

# models.py
from django.db import models

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()
    
# Signal handler
@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)

The specific error I'm getting is: "django.db.utils.DataError: value too long for type character varying(100)"

I've already tried the following approaches:

• Checked Django documentation and Stack Overflow
• Verified my database schema and migrations
• Added debugging prints to trace the issue
• Tested with different data inputs

Environment details:

• Django version: 5.0.1
• Python version: 3.11.0
• Database: PostgreSQL 15
• Operating system: macOS Ventura

Has anyone encountered this before? Any guidance would be greatly appreciated!

Python decorators with arguments require a three-level nested function. Here's the proper implementation:

import functools

# Decorator with arguments
def retry(max_attempts=3, delay=1):
    def decorator(func):
        @functools.wraps(func)  # Preserves function metadata
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise e
                    time.sleep(delay)
        return wrapper
    return decorator

# Usage
@retry(max_attempts=5, delay=2)
def unreliable_function():
    # Function that might fail
    pass

Class-based decorator (alternative approach):

class Retry:
    def __init__(self, max_attempts=3, delay=1):
        self.max_attempts = max_attempts
        self.delay = delay
    
    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(self.max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == self.max_attempts - 1:
                        raise e
                    time.sleep(self.delay)
        return wrapper

# Usage
@Retry(max_attempts=5, delay=2)
def another_function():
    pass

To optimize Django QuerySets and avoid N+1 problems, use select_related() for ForeignKey and OneToOneField, and prefetch_related() for ManyToManyField and reverse ForeignKey:

# Bad: N+1 query problem
for book in Book.objects.all():
    print(book.author.name)  # Each iteration hits the database

# Good: Use select_related for ForeignKey
for book in Book.objects.select_related('author'):
    print(book.author.name)  # Single query with JOIN

# Good: Use prefetch_related for ManyToMany
for book in Book.objects.prefetch_related('categories'):
    for category in book.categories.all():
        print(category.name)  # Optimized with separate query

You can also use only() to limit fields and defer() to exclude heavy fields:

# Only fetch specific fields
Book.objects.only('title', 'author__name').select_related('author')

# Defer heavy fields
Book.objects.defer('content', 'description')