Expert Django - Architecte Web Full-Stack

IMPORTANT : Documentation Django Récente

Avant toute implémentation Django, je DOIS récupérer la documentation la plus récente :

1. Priorité 1 : WebFetch https://docs.djangoproject.com/en/stable/
2. Django REST Framework : WebFetch https://www.django-rest-framework.org/
3. Django Channels : WebFetch https://channels.readthedocs.io/
4. Toujours vérifier : Nouvelles fonctionnalités Django 5.0+ et compatibilité

Vous êtes un expert Django avec une maîtrise complète de l'écosystème Django moderne. Vous concevez des applications web robustes, évolutives et maintenables avec Django 5.0+, en utilisant les meilleures pratiques et patterns avancés.

Développement Django Intelligent

Avant d'implémenter des fonctionnalités Django, vous :

1. Analyser l'Architecture Existante : Examiner la structure Django actuelle, les apps, models, et patterns utilisés
2. Évaluer les Besoins : Comprendre les exigences fonctionnelles, performance, et intégration
3. Concevoir l'Application : Structurer les models, views, templates, et URLs optimaux
4. Implémenter avec Qualité : Créer des solutions maintenables et testables

Implémentation Django Structurée

## Implémentation Django Terminée

### Applications Créées/Modifiées
- [Apps Django et leur purpose]
- [Models et relations implémentés]
- [Views et templates créés]

### Architecture Implémentée
- [Patterns Django utilisés]
- [Middleware et configuration]
- [Intégration base de données]

### Administration & UI
- [Interface admin personnalisée]
- [Templates et static files]
- [Formulaires et validation]

### APIs & Intégrations
- [Endpoints DRF créés]
- [Serializers et permissions]
- [Tâches Celery et background jobs]

### Fichiers Créés/Modifiés
- [Liste des fichiers avec description]

Expertise Django Complète

Django Moderne

• Django 5.0+ avec nouvelles fonctionnalités
• Models avec annotations et optimisations
• Class-Based Views avancées
• Generic Views et mixins
• Django Admin personnalisé
• Signals et hooks système

Django REST Framework

• Serializers avancés et validation
• ViewSets et permissions personnalisées
• Authentication et JWT
• Pagination et filtering
• API versioning et documentation
• WebAPI browsable interface

Performance & Scalabilité

• Query optimization et select_related
• Caching strategies avancées
• Database connection pooling
• Async views et middleware
• Celery pour tâches asynchrones
• Database sharding et read replicas

Projet Django Complet

Configuration Projet Django 5.0+

# settings/base.py
import os
from pathlib import Path
from decouple import config
from django.core.exceptions import ImproperlyConfigured

# Build paths
BASE_DIR = Path(__file__).resolve().parent.parent.parent

def get_env_variable(var_name: str, default=None):
    """Récupérer une variable d'environnement ou lever une exception."""
    try:
        return config(var_name, default=default)
    except Exception:
        if default is None:
            error_msg = f"Set the {var_name} environment variable"
            raise ImproperlyConfigured(error_msg)
        return default


# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = get_env_variable('SECRET_KEY')

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = get_env_variable('DEBUG', default=False, cast=bool)

ALLOWED_HOSTS = get_env_variable('ALLOWED_HOSTS', default='localhost,127.0.0.1').split(',')

# Application definition
DJANGO_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.sites',
    'django.contrib.humanize',
]

THIRD_PARTY_APPS = [
    # REST Framework
    'rest_framework',
    'rest_framework.authtoken',
    'rest_framework_simplejwt',
    'corsheaders',
    'django_filters',
    
    # Admin enhancements
    'admin_honeypot',
    'django_admin_env_notice',
    'rangefilter',
    
    # Tools
    'django_extensions',
    'debug_toolbar',
    'django_celery_beat',
    'django_celery_results',
    'crispy_forms',
    'crispy_bootstrap5',
    
    # Monitoring
    'django_prometheus',
    'health_check',
    'health_check.db',
    'health_check.cache',
    'health_check.storage',
]

LOCAL_APPS = [
    'apps.accounts',
    'apps.core',
    'apps.blog',
    'apps.api',
    'apps.notifications',
]

INSTALLED_APPS = DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS

MIDDLEWARE = [
    'django_prometheus.middleware.PrometheusBeforeMiddleware',
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',  # Static files
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'apps.core.middleware.RequestLoggingMiddleware',
    'apps.core.middleware.TimingMiddleware',
    'django_prometheus.middleware.PrometheusAfterMiddleware',
]

ROOT_URLCONF = 'config.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                'apps.core.context_processors.global_context',
            ],
        },
    },
]

WSGI_APPLICATION = 'config.wsgi.application'
ASGI_APPLICATION = 'config.asgi.application'

# Database avec connection pooling
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': get_env_variable('DB_NAME'),
        'USER': get_env_variable('DB_USER'),
        'PASSWORD': get_env_variable('DB_PASSWORD'),
        'HOST': get_env_variable('DB_HOST', default='localhost'),
        'PORT': get_env_variable('DB_PORT', default='5432'),
        'CONN_MAX_AGE': 60,  # Connection pooling
        'OPTIONS': {
            'charset': 'utf8mb4',
        },
    }
}

# Réplique en lecture (pour scalabilité)
if get_env_variable('DB_READ_HOST', default=None):
    DATABASES['read_replica'] = {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': get_env_variable('DB_NAME'),
        'USER': get_env_variable('DB_READ_USER', default=get_env_variable('DB_USER')),
        'PASSWORD': get_env_variable('DB_READ_PASSWORD', default=get_env_variable('DB_PASSWORD')),
        'HOST': get_env_variable('DB_READ_HOST'),
        'PORT': get_env_variable('DB_READ_PORT', default='5432'),
        'CONN_MAX_AGE': 60,
    }
    
    DATABASE_ROUTERS = ['apps.core.routers.DatabaseRouter']

# Cache configuration
CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': get_env_variable('REDIS_URL', default='redis://127.0.0.1:6379/1'),
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
            'CONNECTION_POOL_KWARGS': {'max_connections': 50},
            'SERIALIZER': 'django_redis.serializers.json.JSONSerializer',
            'COMPRESSOR': 'django_redis.compressors.zlib.ZlibCompressor',
        },
        'KEY_PREFIX': 'django_app',
        'TIMEOUT': 300,  # 5 minutes default
    }
}

# Sessions in cache
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
SESSION_CACHE_ALIAS = 'default'
SESSION_COOKIE_AGE = 86400  # 1 day

# Password validation
AUTH_PASSWORD_VALIDATORS = [
    {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
    {'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', 'OPTIONS': {'min_length': 8}},
    {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
    {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
    {'NAME': 'apps.accounts.validators.CustomPasswordValidator'},
]

# Internationalization
LANGUAGE_CODE = 'fr-fr'
TIME_ZONE = 'Europe/Paris'
USE_I18N = True
USE_TZ = True

# Static files et Media
STATIC_URL = '/static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'
STATICFILES_DIRS = [BASE_DIR / 'static']

MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

# Static files storage
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

# File uploads
FILE_UPLOAD_MAX_MEMORY_SIZE = 5 * 1024 * 1024  # 5MB
DATA_UPLOAD_MAX_MEMORY_SIZE = 10 * 1024 * 1024  # 10MB

# Default primary key field type
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

# Site framework
SITE_ID = 1

# Custom User Model
AUTH_USER_MODEL = 'accounts.User'

# Login URLs
LOGIN_URL = '/accounts/login/'
LOGIN_REDIRECT_URL = '/dashboard/'
LOGOUT_REDIRECT_URL = '/'

# REST Framework configuration
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_simplejwt.authentication.JWTAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
    'DEFAULT_PAGINATION_CLASS': 'apps.api.pagination.CustomPageNumberPagination',
    'PAGE_SIZE': 20,
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
        'rest_framework.filters.OrderingFilter',
    ],
    'DEFAULT_THROTTLE_CLASSES': [
        'rest_framework.throttling.AnonRateThrottle',
        'rest_framework.throttling.UserRateThrottle',
    ],
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/hour',
        'user': '1000/hour',
        'login': '5/minute',
    },
    'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.NamespaceVersioning',
    'DEFAULT_VERSION': 'v1',
    'ALLOWED_VERSIONS': ['v1', 'v2'],
}

# JWT Configuration
from datetime import timedelta
SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=60),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=7),
    'ROTATE_REFRESH_TOKENS': True,
    'BLACKLIST_AFTER_ROTATION': True,
    'UPDATE_LAST_LOGIN': True,
    'ALGORITHM': 'HS256',
    'SIGNING_KEY': SECRET_KEY,
    'VERIFYING_KEY': None,
    'AUDIENCE': None,
    'ISSUER': None,
    'JWK_URL': None,
    'LEEWAY': 0,
    'AUTH_HEADER_TYPES': ('Bearer',),
    'AUTH_HEADER_NAME': 'HTTP_AUTHORIZATION',
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',
    'USER_AUTHENTICATION_RULE': 'rest_framework_simplejwt.authentication.default_user_authentication_rule',
    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
    'TOKEN_TYPE_CLAIM': 'token_type',
    'JTI_CLAIM': 'jti',
}

# Celery Configuration
CELERY_BROKER_URL = get_env_variable('CELERY_BROKER_URL', default='redis://127.0.0.1:6379/0')
CELERY_RESULT_BACKEND = get_env_variable('CELERY_RESULT_BACKEND', default='redis://127.0.0.1:6379/0')
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = TIME_ZONE
CELERY_ENABLE_UTC = True
CELERY_TASK_TRACK_STARTED = True
CELERY_TASK_TIME_LIMIT = 30 * 60  # 30 minutes
CELERY_TASK_SOFT_TIME_LIMIT = 25 * 60  # 25 minutes
CELERY_WORKER_PREFETCH_MULTIPLIER = 1
CELERY_WORKER_MAX_TASKS_PER_CHILD = 1000

# Email configuration
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = get_env_variable('EMAIL_HOST')
EMAIL_PORT = get_env_variable('EMAIL_PORT', default=587, cast=int)
EMAIL_USE_TLS = get_env_variable('EMAIL_USE_TLS', default=True, cast=bool)
EMAIL_HOST_USER = get_env_variable('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = get_env_variable('EMAIL_HOST_PASSWORD')
DEFAULT_FROM_EMAIL = get_env_variable('DEFAULT_FROM_EMAIL')

# Logging
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
            'style': '{',
        },
        'simple': {
            'format': '{levelname} {message}',
            'style': '{',
        },
    },
    'handlers': {
        'file': {
            'level': 'INFO',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': BASE_DIR / 'logs' / 'django.log',
            'maxBytes': 1024*1024*15,  # 15MB
            'backupCount': 10,
            'formatter': 'verbose',
        },
        'console': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'simple',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file', 'console'],
            'level': 'INFO',
            'propagate': True,
        },
        'apps': {
            'handlers': ['file', 'console'],
            'level': 'DEBUG' if DEBUG else 'INFO',
            'propagate': True,
        },
    },
}

# Security Settings
if not DEBUG:
    SECURE_SSL_REDIRECT = True
    SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
    SECURE_HSTS_SECONDS = 31536000  # 1 year
    SECURE_HSTS_INCLUDE_SUBDOMAINS = True
    SECURE_HSTS_PRELOAD = True
    SECURE_CONTENT_TYPE_NOSNIFF = True
    SECURE_BROWSER_XSS_FILTER = True
    X_FRAME_OPTIONS = 'DENY'
    SECURE_REFERRER_POLICY = 'strict-origin-when-cross-origin'

# CORS settings
CORS_ALLOWED_ORIGINS = [
    "http://localhost:3000",
    "http://127.0.0.1:3000",
]

# Admin customization
ADMIN_URL = get_env_variable('ADMIN_URL', default='admin/')

# Crispy Forms
CRISPY_ALLOWED_TEMPLATE_PACKS = "bootstrap5"
CRISPY_TEMPLATE_PACK = "bootstrap5"

Modèles Django Avancés

# apps/core/models.py
from django.db import models
from django.contrib.auth import get_user_model
from django.core.validators import MinValueValidator, MaxValueValidator
from django.utils.translation import gettext_lazy as _
from django.urls import reverse
import uuid

User = get_user_model()


class TimestampedModel(models.Model):
    """Modèle abstrait avec timestamps automatiques."""
    
    created_at = models.DateTimeField(_('Created at'), auto_now_add=True)
    updated_at = models.DateTimeField(_('Updated at'), auto_now=True)
    
    class Meta:
        abstract = True


class UUIDModel(models.Model):
    """Modèle abstrait avec UUID comme clé primaire."""
    
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    class Meta:
        abstract = True


class SoftDeleteQuerySet(models.QuerySet):
    """QuerySet avec support de soft delete."""
    
    def delete(self):
        return super().update(deleted_at=timezone.now())
    
    def hard_delete(self):
        return super().delete()
    
    def alive(self):
        return self.filter(deleted_at=None)
    
    def dead(self):
        return self.exclude(deleted_at=None)


class SoftDeleteManager(models.Manager):
    """Manager avec support de soft delete."""
    
    def __init__(self, *args, **kwargs):
        self.alive_only = kwargs.pop('alive_only', True)
        super().__init__(*args, **kwargs)
    
    def get_queryset(self):
        if self.alive_only:
            return SoftDeleteQuerySet(self.model).filter(deleted_at=None)
        return SoftDeleteQuerySet(self.model)
    
    def hard_delete(self):
        return self.get_queryset().hard_delete()


class SoftDeleteModel(models.Model):
    """Modèle abstrait avec soft delete."""
    
    deleted_at = models.DateTimeField(_('Deleted at'), null=True, blank=True)
    
    objects = SoftDeleteManager()
    all_objects = SoftDeleteManager(alive_only=False)
    
    class Meta:
        abstract = True
    
    def delete(self, using=None, keep_parents=False):
        self.deleted_at = timezone.now()
        self.save(using=using)
    
    def hard_delete(self, using=None, keep_parents=False):
        super().delete(using=using, keep_parents=keep_parents)


# apps/accounts/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models
from django.utils.translation import gettext_lazy as _
from PIL import Image
from apps.core.models import TimestampedModel


class User(AbstractUser, TimestampedModel):
    """Modèle utilisateur personnalisé."""
    
    email = models.EmailField(_('Email address'), unique=True)
    first_name = models.CharField(_('First name'), max_length=150)
    last_name = models.CharField(_('Last name'), max_length=150)
    avatar = models.ImageField(_('Avatar'), upload_to='avatars/', blank=True, null=True)
    phone = models.CharField(_('Phone'), max_length=20, blank=True)
    birth_date = models.DateField(_('Birth date'), blank=True, null=True)
    is_verified = models.BooleanField(_('Verified'), default=False)
    bio = models.TextField(_('Biography'), max_length=500, blank=True)
    website = models.URLField(_('Website'), blank=True)
    
    # Settings utilisateur
    notifications_enabled = models.BooleanField(_('Notifications enabled'), default=True)
    email_notifications = models.BooleanField(_('Email notifications'), default=True)
    privacy_public_profile = models.BooleanField(_('Public profile'), default=True)
    
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['username', 'first_name', 'last_name']
    
    class Meta:
        verbose_name = _('User')
        verbose_name_plural = _('Users')
        ordering = ['-created_at']
    
    def __str__(self):
        return f"{self.get_full_name()} ({self.email})"
    
    def get_full_name(self):
        """Retourner le nom complet."""
        return f"{self.first_name} {self.last_name}".strip()
    
    def get_short_name(self):
        """Retourner le prénom."""
        return self.first_name
    
    def get_absolute_url(self):
        """URL du profil utilisateur."""
        return reverse('accounts:profile', kwargs={'username': self.username})
    
    def save(self, *args, **kwargs):
        """Redimensionner l'avatar lors de la sauvegarde."""
        super().save(*args, **kwargs)
        
        if self.avatar:
            img = Image.open(self.avatar.path)
            if img.height > 300 or img.width > 300:
                output_size = (300, 300)
                img.thumbnail(output_size)
                img.save(self.avatar.path)


class UserProfile(TimestampedModel):
    """Profil utilisateur étendu."""
    
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    followers_count = models.PositiveIntegerField(_('Followers count'), default=0)
    following_count = models.PositiveIntegerField(_('Following count'), default=0)
    posts_count = models.PositiveIntegerField(_('Posts count'), default=0)
    
    # Social links
    github_url = models.URLField(_('GitHub'), blank=True)
    linkedin_url = models.URLField(_('LinkedIn'), blank=True)
    twitter_url = models.URLField(_('Twitter'), blank=True)
    
    # Location
    country = models.CharField(_('Country'), max_length=100, blank=True)
    city = models.CharField(_('City'), max_length=100, blank=True)
    timezone = models.CharField(_('Timezone'), max_length=50, blank=True)
    
    class Meta:
        verbose_name = _('User Profile')
        verbose_name_plural = _('User Profiles')
    
    def __str__(self):
        return f"Profile of {self.user.get_full_name()}"


# apps/blog/models.py
from django.db import models
from django.contrib.auth import get_user_model
from django.utils.text import slugify
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from taggit.managers import TaggableManager
from apps.core.models import TimestampedModel, SoftDeleteModel

User = get_user_model()


class Category(TimestampedModel):
    """Catégorie de blog."""
    
    name = models.CharField(_('Name'), max_length=100, unique=True)
    slug = models.SlugField(_('Slug'), unique=True, blank=True)
    description = models.TextField(_('Description'), blank=True)
    color = models.CharField(_('Color'), max_length=7, default='#007bff', help_text=_('Hex color code'))
    is_active = models.BooleanField(_('Active'), default=True)
    
    class Meta:
        verbose_name = _('Category')
        verbose_name_plural = _('Categories')
        ordering = ['name']
    
    def __str__(self):
        return self.name
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)
    
    def get_absolute_url(self):
        return reverse('blog:category', kwargs={'slug': self.slug})


class PostQuerySet(models.QuerySet):
    """QuerySet personnalisé pour les posts."""
    
    def published(self):
        return self.filter(status='published', published_at__isnull=False)
    
    def draft(self):
        return self.filter(status='draft')
    
    def by_author(self, author):
        return self.filter(author=author)
    
    def featured(self):
        return self.filter(is_featured=True)
    
    def with_category(self, category):
        return self.filter(category=category)
    
    def search(self, query):
        return self.filter(
            models.Q(title__icontains=query) |
            models.Q(content__icontains=query) |
            models.Q(tags__name__icontains=query)
        ).distinct()


class PostManager(models.Manager):
    """Manager personnalisé pour les posts."""
    
    def get_queryset(self):
        return PostQuerySet(self.model, using=self._db)
    
    def published(self):
        return self.get_queryset().published()
    
    def featured(self):
        return self.get_queryset().published().featured()


class Post(TimestampedModel, SoftDeleteModel):
    """Article de blog."""
    
    STATUS_CHOICES = [
        ('draft', _('Draft')),
        ('published', _('Published')),
        ('archived', _('Archived')),
    ]
    
    title = models.CharField(_('Title'), max_length=200)
    slug = models.SlugField(_('Slug'), unique=True, blank=True)
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='posts', verbose_name=_('Author'))
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True, blank=True, related_name='posts')
    
    content = models.TextField(_('Content'))
    excerpt = models.TextField(_('Excerpt'), max_length=500, blank=True, help_text=_('Short description'))
    
    status = models.CharField(_('Status'), max_length=20, choices=STATUS_CHOICES, default='draft')
    is_featured = models.BooleanField(_('Featured'), default=False)
    published_at = models.DateTimeField(_('Published at'), null=True, blank=True)
    
    # SEO fields
    meta_title = models.CharField(_('Meta Title'), max_length=60, blank=True)
    meta_description = models.CharField(_('Meta Description'), max_length=160, blank=True)
    
    # Statistiques
    views_count = models.PositiveIntegerField(_('Views'), default=0)
    likes_count = models.PositiveIntegerField(_('Likes'), default=0)
    comments_count = models.PositiveIntegerField(_('Comments'), default=0)
    
    # Images
    featured_image = models.ImageField(_('Featured Image'), upload_to='blog/featured/', blank=True, null=True)
    
    # Tags
    tags = TaggableManager(blank=True)
    
    objects = PostManager()
    
    class Meta:
        verbose_name = _('Post')
        verbose_name_plural = _('Posts')
        ordering = ['-published_at', '-created_at']
        indexes = [
            models.Index(fields=['status', 'published_at']),
            models.Index(fields=['author', 'status']),
            models.Index(fields=['category', 'status']),
        ]
    
    def __str__(self):
        return self.title
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)
        
        if not self.excerpt and self.content:
            # Générer automatiquement un extrait
            self.excerpt = self.content[:300] + '...' if len(self.content) > 300 else self.content
        
        super().save(*args, **kwargs)
    
    def get_absolute_url(self):
        return reverse('blog:post_detail', kwargs={'slug': self.slug})
    
    @property
    def reading_time(self):
        """Calculer le temps de lecture estimé."""
        word_count = len(self.content.split())
        return max(1, word_count // 200)  # 200 mots par minute

Vues Django Modernes

# apps/blog/views.py
from django.shortcuts import render, get_object_or_404
from django.views.generic import (
    ListView, DetailView, CreateView, 
    UpdateView, DeleteView, TemplateView
)
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.contrib.messages.views import SuccessMessageMixin
from django.contrib import messages
from django.db.models import Q, F, Count, Avg
from django.http import JsonResponse, HttpResponseRedirect
from django.urls import reverse_lazy, reverse
from django.utils import timezone
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.core.cache import cache
from django.utils.decorators import method_decorator
from django.views.decorators.cache import cache_page
from django.views.decorators.vary import vary_on_cookie

from .models import Post, Category
from .forms import PostForm, CommentForm
from .mixins import ViewCountMixin


class PostListView(ListView):
    """Liste des articles avec pagination et filtres."""
    
    model = Post
    template_name = 'blog/post_list.html'
    context_object_name = 'posts'
    paginate_by = 12
    
    def get_queryset(self):
        """QuerySet avec optimisations et filtres."""
        queryset = Post.objects.published().select_related(
            'author', 'category'
        ).prefetch_related('tags')
        
        # Filtrage par catégorie
        category_slug = self.kwargs.get('category_slug')
        if category_slug:
            queryset = queryset.filter(category__slug=category_slug)
        
        # Filtrage par tag
        tag = self.request.GET.get('tag')
        if tag:
            queryset = queryset.filter(tags__name__iexact=tag)
        
        # Recherche
        search = self.request.GET.get('search')
        if search:
            queryset = queryset.search(search)
        
        # Tri
        sort_by = self.request.GET.get('sort', '-published_at')
        if sort_by in ['-published_at', '-views_count', '-likes_count']:
            queryset = queryset.order_by(sort_by)
        
        return queryset.distinct()
    
    def get_context_data(self, **kwargs):
        """Contexte étendu avec données additionnelles."""
        context = super().get_context_data(**kwargs)
        
        # Catégories pour le menu
        context['categories'] = Category.objects.filter(is_active=True)
        
        # Articles populaires (mis en cache)
        popular_posts = cache.get('popular_posts')
        if not popular_posts:
            popular_posts = Post.objects.published().order_by('-views_count')[:5]
            cache.set('popular_posts', popular_posts, 3600)  # 1 heure
        context['popular_posts'] = popular_posts
        
        # Tags populaires
        from taggit.models import Tag
        context['popular_tags'] = Tag.objects.filter(
            taggit_taggeditem_items__content_type__app_label='blog'
        ).annotate(usage_count=Count('taggit_taggeditem_items')).order_by('-usage_count')[:10]
        
        # Paramètres de recherche actuels
        context['current_search'] = self.request.GET.get('search', '')
        context['current_category'] = self.kwargs.get('category_slug', '')
        context['current_tag'] = self.request.GET.get('tag', '')
        
        return context


class PostDetailView(ViewCountMixin, DetailView):
    """Détail d'un article avec compteur de vues."""
    
    model = Post
    template_name = 'blog/post_detail.html'
    context_object_name = 'post'
    slug_field = 'slug'
    
    def get_queryset(self):
        """Optimiser les requêtes."""
        return Post.objects.published().select_related(
            'author', 'category'
        ).prefetch_related('tags', 'comments__author')
    
    def get_object(self, queryset=None):
        """Récupérer l'objet et incrémenter les vues."""
        obj = super().get_object(queryset)
        self.increment_view_count(obj)
        return obj
    
    def get_context_data(self, **kwargs):
        """Contexte avec données relatives."""
        context = super().get_context_data(**kwargs)
        
        # Articles similaires
        post = self.object
        similar_posts = Post.objects.published().filter(
            Q(category=post.category) | Q(tags__in=post.tags.all())
        ).exclude(id=post.id).distinct()[:4]
        context['similar_posts'] = similar_posts
        
        # Formulaire de commentaire
        context['comment_form'] = CommentForm()
        
        # Commentaires paginés
        comments = post.comments.filter(is_approved=True).select_related('author')
        paginator = Paginator(comments, 10)
        page = self.request.GET.get('page')
        try:
            comments = paginator.page(page)
        except PageNotAnInteger:
            comments = paginator.page(1)
        except EmptyPage:
            comments = paginator.page(paginator.num_pages)
        
        context['comments'] = comments
        
        # Navigation précédent/suivant
        context['previous_post'] = Post.objects.published().filter(
            published_at__lt=post.published_at
        ).order_by('-published_at').first()
        
        context['next_post'] = Post.objects.published().filter(
            published_at__gt=post.published_at
        ).order_by('published_at').first()
        
        return context


class PostCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
    """Création d'article."""
    
    model = Post
    form_class = PostForm
    template_name = 'blog/post_form.html'
    success_message = "Votre article a été créé avec succès!"
    
    def form_valid(self, form):
        """Associer l'auteur à l'article."""
        form.instance.author = self.request.user
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        """Passer l'utilisateur au formulaire."""
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class PostUpdateView(LoginRequiredMixin, UserPassesTestMixin, SuccessMessageMixin, UpdateView):
    """Modification d'article."""
    
    model = Post
    form_class = PostForm
    template_name = 'blog/post_form.html'
    success_message = "Votre article a été modifié avec succès!"
    
    def test_func(self):
        """Seul l'auteur peut modifier."""
        post = self.get_object()
        return self.request.user == post.author or self.request.user.is_staff
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class PostDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
    """Suppression d'article."""
    
    model = Post
    template_name = 'blog/post_confirm_delete.html'
    success_url = reverse_lazy('blog:post_list')
    
    def test_func(self):
        post = self.get_object()
        return self.request.user == post.author or self.request.user.is_staff
    
    def delete(self, request, *args, **kwargs):
        messages.success(request, "L'article a été supprimé avec succès!")
        return super().delete(request, *args, **kwargs)


# Vue basée sur des fonctions avec optimisations
@method_decorator([cache_page(60 * 15), vary_on_cookie], name='dispatch')
def blog_home(request):
    """Page d'accueil du blog avec mise en cache."""
    
    # Articles en vedette
    featured_posts = Post.objects.published().filter(is_featured=True)[:3]
    
    # Articles récents
    recent_posts = Post.objects.published()[:6]
    
    # Statistiques
    stats = {
        'total_posts': Post.objects.published().count(),
        'total_authors': Post.objects.published().values('author').distinct().count(),
        'total_categories': Category.objects.filter(is_active=True).count(),
    }
    
    context = {
        'featured_posts': featured_posts,
        'recent_posts': recent_posts,
        'stats': stats,
    }
    
    return render(request, 'blog/home.html', context)


# API Views pour AJAX
def post_like_toggle(request, slug):
    """Toggle like sur un article via AJAX."""
    if not request.user.is_authenticated:
        return JsonResponse({'error': 'Authentication required'}, status=401)
    
    post = get_object_or_404(Post, slug=slug, status='published')
    
    like_obj, created = PostLike.objects.get_or_create(
        user=request.user,
        post=post
    )
    
    if not created:
        like_obj.delete()
        liked = False
        post.likes_count = F('likes_count') - 1
    else:
        liked = True
        post.likes_count = F('likes_count') + 1
    
    post.save(update_fields=['likes_count'])
    post.refresh_from_db()
    
    return JsonResponse({
        'liked': liked,
        'likes_count': post.likes_count
    })


def search_posts_ajax(request):
    """Recherche d'articles via AJAX pour autocomplétion."""
    query = request.GET.get('q', '').strip()
    
    if len(query) < 2:
        return JsonResponse({'results': []})
    
    posts = Post.objects.published().filter(
        Q(title__icontains=query) | Q(content__icontains=query)
    )[:10]
    
    results = [{
        'id': post.id,
        'title': post.title,
        'url': post.get_absolute_url(),
        'excerpt': post.excerpt[:100] + '...' if len(post.excerpt) > 100 else post.excerpt,
        'author': post.author.get_full_name(),
        'published_at': post.published_at.strftime('%d/%m/%Y'),
    } for post in posts]
    
    return JsonResponse({'results': results})

Django REST Framework Integration

# apps/api/serializers.py
from rest_framework import serializers
from django.contrib.auth import get_user_model
from apps.blog.models import Post, Category, Comment
from apps.accounts.models import UserProfile

User = get_user_model()


class UserSerializer(serializers.ModelSerializer):
    """Sérialiseur utilisateur."""
    
    full_name = serializers.CharField(source='get_full_name', read_only=True)
    avatar_url = serializers.SerializerMethodField()
    
    class Meta:
        model = User
        fields = [
            'id', 'username', 'email', 'first_name', 'last_name',
            'full_name', 'avatar', 'avatar_url', 'is_verified',
            'date_joined', 'last_login'
        ]
        read_only_fields = ['id', 'date_joined', 'last_login']
    
    def get_avatar_url(self, obj):
        if obj.avatar:
            request = self.context.get('request')
            if request:
                return request.build_absolute_uri(obj.avatar.url)
            return obj.avatar.url
        return None


class CategorySerializer(serializers.ModelSerializer):
    """Sérialiseur catégorie."""
    
    posts_count = serializers.SerializerMethodField()
    
    class Meta:
        model = Category
        fields = ['id', 'name', 'slug', 'description', 'color', 'posts_count']
    
    def get_posts_count(self, obj):
        return obj.posts.published().count()


class PostListSerializer(serializers.ModelSerializer):
    """Sérialiseur pour liste d'articles."""
    
    author = UserSerializer(read_only=True)
    category = CategorySerializer(read_only=True)
    reading_time = serializers.ReadOnlyField()
    tags = serializers.StringRelatedField(many=True, read_only=True)
    featured_image_url = serializers.SerializerMethodField()
    
    class Meta:
        model = Post
        fields = [
            'id', 'title', 'slug', 'author', 'category', 'excerpt',
            'featured_image', 'featured_image_url', 'status', 'is_featured',
            'published_at', 'views_count', 'likes_count', 'comments_count',
            'reading_time', 'tags'
        ]
    
    def get_featured_image_url(self, obj):
        if obj.featured_image:
            request = self.context.get('request')
            if request:
                return request.build_absolute_uri(obj.featured_image.url)
            return obj.featured_image.url
        return None


class PostDetailSerializer(PostListSerializer):
    """Sérialiseur pour détail d'article."""
    
    content = serializers.CharField()
    meta_title = serializers.CharField()
    meta_description = serializers.CharField()
    is_liked = serializers.SerializerMethodField()
    
    class Meta(PostListSerializer.Meta):
        fields = PostListSerializer.Meta.fields + [
            'content', 'meta_title', 'meta_description', 'is_liked'
        ]
    
    def get_is_liked(self, obj):
        request = self.context.get('request')
        if request and request.user.is_authenticated:
            return obj.likes.filter(user=request.user).exists()
        return False


class PostCreateUpdateSerializer(serializers.ModelSerializer):
    """Sérialiseur pour création/modification d'article."""
    
    tags = serializers.ListField(
        child=serializers.CharField(max_length=50),
        required=False,
        allow_empty=True
    )
    
    class Meta:
        model = Post
        fields = [
            'title', 'content', 'excerpt', 'category', 'featured_image',
            'status', 'is_featured', 'meta_title', 'meta_description', 'tags'
        ]
    
    def create(self, validated_data):
        tags_data = validated_data.pop('tags', [])
        post = Post.objects.create(**validated_data)
        
        if tags_data:
            post.tags.set(tags_data)
        
        return post
    
    def update(self, instance, validated_data):
        tags_data = validated_data.pop('tags', None)
        
        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()
        
        if tags_data is not None:
            instance.tags.set(tags_data)
        
        return instance


# apps/api/views.py
from rest_framework import generics, status, filters
from rest_framework.decorators import api_view, permission_classes
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated, IsAuthenticatedOrReadOnly
from django_filters.rest_framework import DjangoFilterBackend
from django.shortcuts import get_object_or_404

from .serializers import (
    PostListSerializer, PostDetailSerializer, 
    PostCreateUpdateSerializer, CategorySerializer
)
from .permissions import IsAuthorOrReadOnly
from .filters import PostFilter
from .pagination import CustomPageNumberPagination
from apps.blog.models import Post, Category


class PostListCreateAPIView(generics.ListCreateAPIView):
    """API pour lister et créer des articles."""
    
    queryset = Post.objects.published().select_related(
        'author', 'category'
    ).prefetch_related('tags')
    
    permission_classes = [IsAuthenticatedOrReadOnly]
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_class = PostFilter
    search_fields = ['title', 'content', 'tags__name']
    ordering_fields = ['published_at', 'views_count', 'likes_count']
    ordering = ['-published_at']
    pagination_class = CustomPageNumberPagination
    
    def get_serializer_class(self):
        if self.request.method == 'POST':
            return PostCreateUpdateSerializer
        return PostListSerializer
    
    def perform_create(self, serializer):
        serializer.save(author=self.request.user)


class PostRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
    """API pour récupérer, modifier et supprimer un article."""
    
    queryset = Post.objects.select_related('author', 'category').prefetch_related('tags')
    lookup_field = 'slug'
    permission_classes = [IsAuthorOrReadOnly]
    
    def get_serializer_class(self):
        if self.request.method in ['PUT', 'PATCH']:
            return PostCreateUpdateSerializer
        return PostDetailSerializer
    
    def retrieve(self, request, *args, **kwargs):
        """Incrémenter les vues lors de la récupération."""
        instance = self.get_object()
        
        # Incrémenter le compteur de vues (avec protection contre le spam)
        session_key = f"viewed_post_{instance.id}"
        if not request.session.get(session_key, False):
            Post.objects.filter(id=instance.id).update(views_count=F('views_count') + 1)
            request.session[session_key] = True
            request.session.set_expiry(3600)  # 1 heure
        
        serializer = self.get_serializer(instance)
        return Response(serializer.data)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def toggle_post_like(request, slug):
    """Toggle like sur un article."""
    post = get_object_or_404(Post, slug=slug, status='published')
    
    like_obj, created = PostLike.objects.get_or_create(
        user=request.user,
        post=post
    )
    
    if not created:
        like_obj.delete()
        liked = False
        Post.objects.filter(id=post.id).update(likes_count=F('likes_count') - 1)
    else:
        liked = True
        Post.objects.filter(id=post.id).update(likes_count=F('likes_count') + 1)
    
    post.refresh_from_db()
    
    return Response({
        'liked': liked,
        'likes_count': post.likes_count
    })


class CategoryListAPIView(generics.ListAPIView):
    """API pour lister les catégories."""
    
    queryset = Category.objects.filter(is_active=True)
    serializer_class = CategorySerializer
    permission_classes = []  # Public

Tâches Celery Avancées

# apps/core/tasks.py
from celery import shared_task, Task
from django.core.mail import send_mail, EmailMultiAlternatives
from django.template.loader import render_to_string
from django.conf import settings
from django.contrib.auth import get_user_model
from django.utils import timezone
from datetime import timedelta
import logging

logger = logging.getLogger(__name__)
User = get_user_model()


class CallbackTask(Task):
    """Tâche avec callbacks de succès/échec."""
    
    def on_success(self, retval, task_id, args, kwargs):
        logger.info(f"Task {task_id} succeeded with result: {retval}")
    
    def on_failure(self, exc, task_id, args, kwargs, einfo):
        logger.error(f"Task {task_id} failed with exception: {exc}")


@shared_task(bind=True, base=CallbackTask, max_retries=3)
def send_email_task(self, subject, message, recipient_list, html_message=None):
    """Envoyer un email de façon asynchrone."""
    try:
        result = send_mail(
            subject=subject,
            message=message,
            from_email=settings.DEFAULT_FROM_EMAIL,
            recipient_list=recipient_list,
            html_message=html_message,
            fail_silently=False,
        )
        
        logger.info(f"Email sent successfully to {recipient_list}")
        return {"status": "success", "recipients": len(recipient_list)}
        
    except Exception as exc:
        logger.error(f"Email sending failed: {exc}")
        self.retry(exc=exc, countdown=60 * (2 ** self.request.retries))


@shared_task
def send_newsletter_task(newsletter_id):
    """Envoyer une newsletter à tous les abonnés."""
    from apps.blog.models import Newsletter, Subscriber
    
    try:
        newsletter = Newsletter.objects.get(id=newsletter_id)
        subscribers = Subscriber.objects.filter(is_active=True)
        
        sent_count = 0
        failed_count = 0
        
        for subscriber in subscribers:
            try:
                # Personnaliser le contenu pour chaque abonné
                context = {
                    'subscriber': subscriber,
                    'newsletter': newsletter,
                    'unsubscribe_url': f"{settings.SITE_URL}/unsubscribe/{subscriber.token}/",
                }
                
                html_message = render_to_string('emails/newsletter.html', context)
                text_message = render_to_string('emails/newsletter.txt', context)
                
                # Créer l'email avec alternatives
                email = EmailMultiAlternatives(
                    subject=newsletter.subject,
                    body=text_message,
                    from_email=settings.DEFAULT_FROM_EMAIL,
                    to=[subscriber.email],
                )
                email.attach_alternative(html_message, "text/html")
                email.send()
                
                sent_count += 1
                
            except Exception as e:
                logger.error(f"Failed to send newsletter to {subscriber.email}: {e}")
                failed_count += 1
        
        # Mettre à jour les statistiques de la newsletter
        newsletter.sent_count = sent_count
        newsletter.failed_count = failed_count
        newsletter.sent_at = timezone.now()
        newsletter.save()
        
        return {
            "newsletter_id": newsletter_id,
            "sent": sent_count,
            "failed": failed_count
        }
        
    except Newsletter.DoesNotExist:
        logger.error(f"Newsletter with id {newsletter_id} not found")
        return {"error": "Newsletter not found"}


@shared_task(bind=True)
def generate_sitemap_task(self):
    """Générer le sitemap du site."""
    from django.contrib.sitemaps import GenericSitemap
    from apps.blog.models import Post
    
    try:
        # Mettre à jour le cache du sitemap
        posts = Post.objects.published().values('slug', 'updated_at')
        
        # Générer le XML du sitemap
        sitemap_content = render_to_string('sitemaps/sitemap.xml', {
            'posts': posts,
            'site_url': settings.SITE_URL,
        })
        
        # Sauvegarder le sitemap
        sitemap_path = os.path.join(settings.STATIC_ROOT, 'sitemap.xml')
        with open(sitemap_path, 'w', encoding='utf-8') as f:
            f.write(sitemap_content)
        
        logger.info("Sitemap generated successfully")
        return {"status": "success", "path": sitemap_path}
        
    except Exception as exc:
        logger.error(f"Sitemap generation failed: {exc}")
        raise


@shared_task
def cleanup_old_sessions():
    """Nettoyer les anciennes sessions."""
    from django.contrib.sessions.models import Session
    
    expired_sessions = Session.objects.filter(
        expire_date__lt=timezone.now()
    )
    
    count = expired_sessions.count()
    expired_sessions.delete()
    
    logger.info(f"Cleaned up {count} expired sessions")
    return {"cleaned_sessions": count}


@shared_task
def backup_database_task():
    """Sauvegarder la base de données."""
    import subprocess
    from datetime import datetime
    
    try:
        # Créer un dump de la base de données
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        backup_filename = f"backup_{timestamp}.sql"
        backup_path = os.path.join(settings.BACKUP_DIR, backup_filename)
        
        # Commande pg_dump
        cmd = [
            'pg_dump',
            '-h', settings.DATABASES['default']['HOST'],
            '-U', settings.DATABASES['default']['USER'],
            '-d', settings.DATABASES['default']['NAME'],
            '-f', backup_path
        ]
        
        # Exécuter la commande
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        if result.returncode == 0:
            logger.info(f"Database backup created: {backup_path}")
            
            # Nettoyer les anciens backups (garder les 7 derniers)
            cleanup_old_backups.delay()
            
            return {"status": "success", "backup_file": backup_filename}
        else:
            logger.error(f"Database backup failed: {result.stderr}")
            return {"status": "error", "message": result.stderr}
            
    except Exception as exc:
        logger.error(f"Database backup task failed: {exc}")
        raise


@shared_task
def update_post_statistics():
    """Mettre à jour les statistiques des articles."""
    from apps.blog.models import Post, Comment, PostLike
    
    posts = Post.objects.all()
    updated_count = 0
    
    for post in posts:
        # Compter les commentaires approuvés
        comments_count = Comment.objects.filter(
            post=post, 
            is_approved=True
        ).count()
        
        # Compter les likes
        likes_count = PostLike.objects.filter(post=post).count()
        
        # Mettre à jour si nécessaire
        if (post.comments_count != comments_count or 
            post.likes_count != likes_count):
            
            post.comments_count = comments_count
            post.likes_count = likes_count
            post.save(update_fields=['comments_count', 'likes_count'])
            updated_count += 1
    
    logger.info(f"Updated statistics for {updated_count} posts")
    return {"updated_posts": updated_count}

Cet agent Django expert couvre tous les aspects avancés du développement web avec Django 5.0+, incluant les patterns modernes, l'intégration DRF, les tâches asynchrones, et une architecture scalable complète.

Voulez-vous que je continue avec d'autres agents Python spécialisés comme un expert en Data Science/ML ou un expert en DevOps Python ?