claude-flow-novice 1.0.0

package/wiki/languages/python/web-development/README.md

@@ -0,0 +1,974 @@
+# Python Web Development with Claude-Flow
+
+Comprehensive guide to building modern web applications using Django, Flask, and FastAPI with intelligent agent assistance for rapid development and deployment.
+
+## 🌐 Web Framework Overview
+
+### Framework Selection Guide
+
+| Framework | Best For | Agent Assistance | Complexity |
+|-----------|----------|-----------------|------------|
+| **FastAPI** | Modern APIs, async workloads | `backend-dev`, `api-docs` | Medium |
+| **Django** | Full-stack web apps, admin interfaces | `backend-dev`, `system-architect` | High |
+| **Flask** | Microservices, lightweight APIs | `backend-dev`, `coder` | Low |
+
+## ⚡ FastAPI Development
+
+### Quick Start with Claude-Flow
+
+```bash
+# Initialize FastAPI project with agents
+npx claude-flow@alpha sparc run architect "FastAPI microservice with authentication"
+
+# Spawn specialized agents for FastAPI development
+Task("Backend Developer", "Create FastAPI app with SQLAlchemy and Pydantic", "backend-dev")
+Task("API Designer", "Design RESTful endpoints with OpenAPI docs", "api-docs")
+Task("Database Architect", "Setup PostgreSQL with Alembic migrations", "code-analyzer")
+Task("Security Engineer", "Implement JWT authentication and authorization", "reviewer")
+Task("Test Engineer", "Create comprehensive test suite with pytest", "tester")
+```
+
+### FastAPI Project Structure
+
+```
+fastapi-project/
+├── app/
+│   ├── __init__.py
+│   ├── main.py                 # FastAPI application
+│   ├── core/
+│   │   ├── config.py           # Configuration
+│   │   ├── database.py         # Database connection
+│   │   └── security.py         # Authentication
+│   ├── api/
+│   │   ├── __init__.py
+│   │   ├── deps.py             # Dependencies
+│   │   └── endpoints/
+│   │       ├── auth.py         # Authentication endpoints
+│   │       ├── users.py        # User management
+│   │       └── items.py        # Business logic
+│   ├── models/                 # SQLAlchemy models
+│   ├── schemas/                # Pydantic schemas
+│   ├── services/               # Business logic
+│   └── utils/                  # Utilities
+├── tests/                      # Test suite
+├── alembic/                    # Database migrations
+├── docker-compose.yml
+├── Dockerfile
+└── pyproject.toml
+```
+
+### FastAPI Implementation Example
+
+```python
+# app/main.py - Generated by claude-flow backend-dev agent
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy.orm import Session
+import uvicorn
+
+from app.core.config import settings
+from app.core.database import get_db
+from app.core.security import verify_password, create_access_token
+from app.api.endpoints import auth, users, items
+from app.models.user import User
+from app.schemas.user import UserCreate, UserResponse
+from app.schemas.token import Token
+
+app = FastAPI(
+    title="Claude-Flow FastAPI",
+    description="Modern API built with AI assistance",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_HOSTS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(auth.router, prefix="/auth", tags=["authentication"])
+app.include_router(users.router, prefix="/users", tags=["users"])
+app.include_router(items.router, prefix="/items", tags=["items"])
+
+@app.get("/")
+async def root():
+    return {"message": "Claude-Flow FastAPI is running!"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "version": "1.0.0"}
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True
+    )
+```
+
+### Authentication with JWT
+
+```python
+# app/core/security.py - Security implementation
+from datetime import datetime, timedelta
+from typing import Optional, Union
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+
+from app.core.config import settings
+from app.core.database import get_db
+from app.models.user import User
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/login")
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify password against hash."""
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password: str) -> str:
+    """Generate password hash."""
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """Create JWT access token."""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm="HS256")
+    return encoded_jwt
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: Session = Depends(get_db)
+) -> User:
+    """Get current authenticated user."""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        email: str = payload.get("sub")
+        if email is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+
+    user = db.query(User).filter(User.email == email).first()
+    if user is None:
+        raise credentials_exception
+    return user
+```
+
+### API Endpoints with Pydantic
+
+```python
+# app/api/endpoints/users.py - User management endpoints
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.models.user import User
+from app.schemas.user import UserCreate, UserUpdate, UserResponse
+from app.services.user_service import UserService
+
+router = APIRouter()
+
+@router.post("/", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
+async def create_user(
+    user_data: UserCreate,
+    db: Session = Depends(get_db)
+):
+    """Create new user."""
+    user_service = UserService(db)
+
+    # Check if user already exists
+    if user_service.get_by_email(user_data.email):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Email already registered"
+        )
+
+    user = user_service.create(user_data)
+    return user
+
+@router.get("/me", response_model=UserResponse)
+async def get_current_user_info(
+    current_user: User = Depends(get_current_user)
+):
+    """Get current user information."""
+    return current_user
+
+@router.get("/", response_model=List[UserResponse])
+async def list_users(
+    skip: int = 0,
+    limit: int = 100,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """List all users (admin only)."""
+    if not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not enough permissions"
+        )
+
+    user_service = UserService(db)
+    users = user_service.get_multi(skip=skip, limit=limit)
+    return users
+
+@router.put("/{user_id}", response_model=UserResponse)
+async def update_user(
+    user_id: int,
+    user_data: UserUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Update user information."""
+    user_service = UserService(db)
+    user = user_service.get(user_id)
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+
+    # Check permissions
+    if user_id != current_user.id and not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not enough permissions"
+        )
+
+    updated_user = user_service.update(user, user_data)
+    return updated_user
+```
+
+## 🎨 Django Development
+
+### Django Project Setup with Agents
+
+```bash
+# Initialize Django project with claude-flow
+Task("Django Developer", "Create Django project with modern architecture", "backend-dev")
+Task("Database Architect", "Design Django models with relationships", "code-analyzer")
+Task("Frontend Developer", "Create Django templates with Bootstrap", "coder")
+Task("API Developer", "Add Django REST Framework for API endpoints", "api-docs")
+
+# Automated Django setup includes:
+# - Django project structure
+# - Custom user model
+# - Django REST Framework
+# - Celery for background tasks
+# - PostgreSQL configuration
+# - Docker setup
+```
+
+### Django Project Structure
+
+```
+django-project/
+├── manage.py
+├── requirements/
+│   ├── base.txt
+│   ├── development.txt
+│   └── production.txt
+├── config/
+│   ├── __init__.py
+│   ├── settings/
+│   │   ├── __init__.py
+│   │   ├── base.py
+│   │   ├── development.py
+│   │   └── production.py
+│   ├── urls.py
+│   └── wsgi.py
+├── apps/
+│   ├── __init__.py
+│   ├── accounts/          # Custom user management
+│   ├── core/              # Core utilities
+│   ├── api/               # REST API
+│   └── dashboard/         # Admin dashboard
+├── static/
+├── media/
+├── templates/
+├── locale/
+└── tests/
+```
+
+### Django Models with Relationships
+
+```python
+# apps/accounts/models.py - User management
+from django.contrib.auth.models import AbstractUser
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+class User(AbstractUser):
+    """Custom user model with additional fields."""
+    email = models.EmailField(_('email address'), unique=True)
+    first_name = models.CharField(_('first name'), max_length=150, blank=True)
+    last_name = models.CharField(_('last name'), max_length=150, blank=True)
+    bio = models.TextField(_('biography'), max_length=500, blank=True)
+    location = models.CharField(_('location'), max_length=30, blank=True)
+    birth_date = models.DateField(_('birth date'), null=True, blank=True)
+    avatar = models.ImageField(_('avatar'), upload_to='avatars/', null=True, blank=True)
+    is_verified = models.BooleanField(_('verified'), default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['username', 'first_name', 'last_name']
+
+    class Meta:
+        verbose_name = _('User')
+        verbose_name_plural = _('Users')
+
+    def __str__(self):
+        return self.email
+
+# apps/core/models.py - Base models
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+class TimeStampedModel(models.Model):
+    """Abstract base class with self-updating created and modified fields."""
+    created_at = models.DateTimeField(_('created at'), auto_now_add=True)
+    updated_at = models.DateTimeField(_('updated at'), auto_now=True)
+
+    class Meta:
+        abstract = True
+
+class Category(TimeStampedModel):
+    """Product category model."""
+    name = models.CharField(_('name'), max_length=100, unique=True)
+    slug = models.SlugField(_('slug'), unique=True)
+    description = models.TextField(_('description'), blank=True)
+    parent = models.ForeignKey(
+        'self',
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+        related_name='children',
+        verbose_name=_('parent category')
+    )
+    is_active = models.BooleanField(_('active'), default=True)
+
+    class Meta:
+        verbose_name = _('Category')
+        verbose_name_plural = _('Categories')
+        ordering = ['name']
+
+    def __str__(self):
+        return self.name
+
+class Product(TimeStampedModel):
+    """Product model with relationships."""
+    name = models.CharField(_('name'), max_length=200)
+    slug = models.SlugField(_('slug'), unique=True)
+    description = models.TextField(_('description'))
+    price = models.DecimalField(_('price'), max_digits=10, decimal_places=2)
+    category = models.ForeignKey(
+        Category,
+        on_delete=models.PROTECT,
+        related_name='products',
+        verbose_name=_('category')
+    )
+    created_by = models.ForeignKey(
+        'accounts.User',
+        on_delete=models.PROTECT,
+        related_name='products',
+        verbose_name=_('created by')
+    )
+    is_available = models.BooleanField(_('available'), default=True)
+    stock_quantity = models.PositiveIntegerField(_('stock quantity'), default=0)
+
+    class Meta:
+        verbose_name = _('Product')
+        verbose_name_plural = _('Products')
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return self.name
+```
+
+### Django REST Framework API
+
+```python
+# apps/api/serializers.py - API serializers
+from rest_framework import serializers
+from django.contrib.auth import get_user_model
+from apps.core.models import Category, Product
+
+User = get_user_model()
+
+class UserSerializer(serializers.ModelSerializer):
+    """User serializer for API responses."""
+
+    class Meta:
+        model = User
+        fields = [
+            'id', 'username', 'email', 'first_name', 'last_name',
+            'bio', 'location', 'avatar', 'is_verified', 'created_at'
+        ]
+        read_only_fields = ['id', 'created_at', 'is_verified']
+
+class CategorySerializer(serializers.ModelSerializer):
+    """Category serializer with nested children."""
+    children = serializers.SerializerMethodField()
+    products_count = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Category
+        fields = [
+            'id', 'name', 'slug', 'description', 'parent',
+            'is_active', 'children', 'products_count'
+        ]
+
+    def get_children(self, obj):
+        if obj.children.exists():
+            return CategorySerializer(obj.children.all(), many=True).data
+        return []
+
+    def get_products_count(self, obj):
+        return obj.products.filter(is_available=True).count()
+
+class ProductSerializer(serializers.ModelSerializer):
+    """Product serializer with related data."""
+    category = CategorySerializer(read_only=True)
+    created_by = UserSerializer(read_only=True)
+    category_id = serializers.IntegerField(write_only=True)
+
+    class Meta:
+        model = Product
+        fields = [
+            'id', 'name', 'slug', 'description', 'price',
+            'category', 'category_id', 'created_by', 'is_available',
+            'stock_quantity', 'created_at', 'updated_at'
+        ]
+
+    def create(self, validated_data):
+        validated_data['created_by'] = self.context['request'].user
+        return super().create(validated_data)
+
+# apps/api/views.py - API views
+from rest_framework import viewsets, permissions, filters
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from django_filters.rest_framework import DjangoFilterBackend
+from apps.core.models import Category, Product
+from .serializers import CategorySerializer, ProductSerializer
+from .filters import ProductFilter
+
+class CategoryViewSet(viewsets.ModelViewSet):
+    """Category management API."""
+    queryset = Category.objects.filter(is_active=True)
+    serializer_class = CategorySerializer
+    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
+    lookup_field = 'slug'
+
+    @action(detail=True, methods=['get'])
+    def products(self, request, slug=None):
+        """Get products in category."""
+        category = self.get_object()
+        products = category.products.filter(is_available=True)
+        serializer = ProductSerializer(products, many=True)
+        return Response(serializer.data)
+
+class ProductViewSet(viewsets.ModelViewSet):
+    """Product management API."""
+    queryset = Product.objects.select_related('category', 'created_by')
+    serializer_class = ProductSerializer
+    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
+    filter_backends = [
+        DjangoFilterBackend,
+        filters.SearchFilter,
+        filters.OrderingFilter
+    ]
+    filterset_class = ProductFilter
+    search_fields = ['name', 'description']
+    ordering_fields = ['name', 'price', 'created_at']
+    ordering = ['-created_at']
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        if self.action == 'list':
+            return queryset.filter(is_available=True)
+        return queryset
+
+    @action(detail=False, methods=['get'])
+    def featured(self, request):
+        """Get featured products."""
+        products = self.get_queryset().filter(
+            stock_quantity__gt=0
+        )[:10]
+        serializer = self.get_serializer(products, many=True)
+        return Response(serializer.data)
+```
+
+## 🔹 Flask Development
+
+### Flask Application with Blueprints
+
+```bash
+# Initialize Flask project with claude-flow
+Task("Flask Developer", "Create Flask application with blueprints and SQLAlchemy", "backend-dev")
+Task("API Designer", "Design RESTful API with Flask-RESTful", "api-docs")
+Task("Database Engineer", "Setup Flask-SQLAlchemy with migrations", "code-analyzer")
+```
+
+### Flask Project Structure
+
+```
+flask-project/
+├── app/
+│   ├── __init__.py             # Application factory
+│   ├── extensions.py           # Extensions initialization
+│   ├── config.py               # Configuration
+│   ├── models/
+│   │   ├── __init__.py
+│   │   ├── user.py
+│   │   └── product.py
+│   ├── blueprints/
+│   │   ├── __init__.py
+│   │   ├── auth/
+│   │   ├── api/
+│   │   └── main/
+│   ├── utils/
+│   └── templates/
+├── migrations/                 # Database migrations
+├── tests/
+├── requirements.txt
+└── run.py
+```
+
+### Flask Application Factory
+
+```python
+# app/__init__.py - Application factory pattern
+from flask import Flask
+from app.extensions import db, migrate, jwt, cors
+from app.config import Config
+
+def create_app(config_class=Config):
+    """Create and configure Flask application."""
+    app = Flask(__name__)
+    app.config.from_object(config_class)
+
+    # Initialize extensions
+    db.init_app(app)
+    migrate.init_app(app, db)
+    jwt.init_app(app)
+    cors.init_app(app)
+
+    # Register blueprints
+    from app.blueprints.auth import bp as auth_bp
+    app.register_blueprint(auth_bp, url_prefix='/auth')
+
+    from app.blueprints.api import bp as api_bp
+    app.register_blueprint(api_bp, url_prefix='/api')
+
+    from app.blueprints.main import bp as main_bp
+    app.register_blueprint(main_bp)
+
+    return app
+
+# app/extensions.py - Extensions
+from flask_sqlalchemy import SQLAlchemy
+from flask_migrate import Migrate
+from flask_jwt_extended import JWTManager
+from flask_cors import CORS
+
+db = SQLAlchemy()
+migrate = Migrate()
+jwt = JWTManager()
+cors = CORS()
+
+# app/models/user.py - User model
+from werkzeug.security import generate_password_hash, check_password_hash
+from app.extensions import db
+
+class User(db.Model):
+    """User model with authentication."""
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(64), index=True, unique=True, nullable=False)
+    email = db.Column(db.String(120), index=True, unique=True, nullable=False)
+    password_hash = db.Column(db.String(255))
+    is_active = db.Column(db.Boolean, default=True)
+    created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
+
+    def set_password(self, password):
+        """Set password hash."""
+        self.password_hash = generate_password_hash(password)
+
+    def check_password(self, password):
+        """Check password against hash."""
+        return check_password_hash(self.password_hash, password)
+
+    def to_dict(self):
+        """Convert to dictionary."""
+        return {
+            'id': self.id,
+            'username': self.username,
+            'email': self.email,
+            'is_active': self.is_active,
+            'created_at': self.created_at.isoformat()
+        }
+
+    def __repr__(self):
+        return f'<User {self.username}>'
+```
+
+## 🧪 Web Development Testing
+
+### FastAPI Testing with pytest
+
+```python
+# tests/test_fastapi.py - FastAPI testing
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from app.main import app
+from app.core.database import get_db, Base
+
+# Test database
+SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
+engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
+TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+@pytest.fixture
+def db_session():
+    """Create test database session."""
+    Base.metadata.create_all(bind=engine)
+    db = TestingSessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+        Base.metadata.drop_all(bind=engine)
+
+@pytest.fixture
+def client(db_session):
+    """Create test client."""
+    def override_get_db():
+        try:
+            yield db_session
+        finally:
+            db_session.close()
+
+    app.dependency_overrides[get_db] = override_get_db
+    with TestClient(app) as test_client:
+        yield test_client
+
+@pytest.fixture
+def test_user(client, db_session):
+    """Create test user."""
+    user_data = {
+        "email": "test@example.com",
+        "password": "testpass123",
+        "full_name": "Test User"
+    }
+    response = client.post("/auth/register", json=user_data)
+    return response.json()
+
+def test_user_registration(client):
+    """Test user registration."""
+    user_data = {
+        "email": "newuser@example.com",
+        "password": "password123",
+        "full_name": "New User"
+    }
+    response = client.post("/auth/register", json=user_data)
+
+    assert response.status_code == 201
+    data = response.json()
+    assert data["email"] == user_data["email"]
+    assert "id" in data
+
+def test_user_login(client, test_user):
+    """Test user login."""
+    login_data = {
+        "username": "test@example.com",
+        "password": "testpass123"
+    }
+    response = client.post("/auth/login", data=login_data)
+
+    assert response.status_code == 200
+    data = response.json()
+    assert "access_token" in data
+    assert data["token_type"] == "bearer"
+
+def test_protected_endpoint(client, test_user):
+    """Test protected endpoint access."""
+    # Login first
+    login_data = {
+        "username": "test@example.com",
+        "password": "testpass123"
+    }
+    login_response = client.post("/auth/login", data=login_data)
+    token = login_response.json()["access_token"]
+
+    # Access protected endpoint
+    headers = {"Authorization": f"Bearer {token}"}
+    response = client.get("/users/me", headers=headers)
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == "test@example.com"
+```
+
+### Django Testing with pytest-django
+
+```python
+# tests/test_django.py - Django testing
+import pytest
+from django.contrib.auth import get_user_model
+from django.urls import reverse
+from rest_framework.test import APIClient
+from rest_framework import status
+from apps.core.models import Category, Product
+
+User = get_user_model()
+
+@pytest.fixture
+def api_client():
+    """Create API client."""
+    return APIClient()
+
+@pytest.fixture
+def user(db):
+    """Create test user."""
+    return User.objects.create_user(
+        username='testuser',
+        email='test@example.com',
+        password='testpass123'
+    )
+
+@pytest.fixture
+def category(db):
+    """Create test category."""
+    return Category.objects.create(
+        name='Test Category',
+        slug='test-category',
+        description='Test category description'
+    )
+
+@pytest.fixture
+def product(db, category, user):
+    """Create test product."""
+    return Product.objects.create(
+        name='Test Product',
+        slug='test-product',
+        description='Test product description',
+        price='99.99',
+        category=category,
+        created_by=user,
+        stock_quantity=10
+    )
+
+@pytest.mark.django_db
+def test_user_registration(api_client):
+    """Test user registration via API."""
+    url = reverse('api:user-list')
+    data = {
+        'username': 'newuser',
+        'email': 'newuser@example.com',
+        'password': 'newpass123',
+        'first_name': 'New',
+        'last_name': 'User'
+    }
+
+    response = api_client.post(url, data)
+
+    assert response.status_code == status.HTTP_201_CREATED
+    assert User.objects.filter(email='newuser@example.com').exists()
+
+@pytest.mark.django_db
+def test_product_list(api_client, product):
+    """Test product list endpoint."""
+    url = reverse('api:product-list')
+    response = api_client.get(url)
+
+    assert response.status_code == status.HTTP_200_OK
+    data = response.json()
+    assert len(data['results']) == 1
+    assert data['results'][0]['name'] == 'Test Product'
+
+@pytest.mark.django_db
+def test_authenticated_product_creation(api_client, user, category):
+    """Test authenticated product creation."""
+    api_client.force_authenticate(user=user)
+
+    url = reverse('api:product-list')
+    data = {
+        'name': 'New Product',
+        'slug': 'new-product',
+        'description': 'New product description',
+        'price': '149.99',
+        'category_id': category.id,
+        'stock_quantity': 5
+    }
+
+    response = api_client.post(url, data)
+
+    assert response.status_code == status.HTTP_201_CREATED
+    assert Product.objects.filter(name='New Product').exists()
+```
+
+## 🚀 Deployment Strategies
+
+### Docker Deployment
+
+```yaml
+# docker-compose.production.yml
+version: '3.8'
+
+services:
+  web:
+    build: .
+    command: gunicorn app.main:app --bind 0.0.0.0:8000 --workers 4
+    ports:
+      - "8000:8000"
+    environment:
+      - DATABASE_URL=postgresql://postgres:password@db:5432/proddb
+      - REDIS_URL=redis://redis:6379
+    depends_on:
+      - db
+      - redis
+
+  db:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_DB: proddb
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+  redis:
+    image: redis:7-alpine
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+      - ./ssl:/etc/nginx/ssl
+    depends_on:
+      - web
+
+volumes:
+  postgres_data:
+```
+
+### CI/CD with GitHub Actions
+
+```yaml
+# .github/workflows/python-web.yml
+name: Python Web Application CI/CD
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:15
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: test_db
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+      with:
+        version: latest
+        virtualenvs-create: true
+        virtualenvs-in-project: true
+
+    - name: Load cached venv
+      id: cached-poetry-dependencies
+      uses: actions/cache@v3
+      with:
+        path: .venv
+        key: venv-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
+
+    - name: Install dependencies
+      if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+      run: poetry install --no-interaction --no-root
+
+    - name: Install project
+      run: poetry install --no-interaction
+
+    - name: Run tests
+      run: |
+        poetry run pytest --cov=app --cov-report=xml
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v3
+
+  deploy:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Deploy to production
+      run: |
+        # Deploy using your preferred method
+        echo "Deploying to production..."
+```
+
+## 📚 Next Steps
+
+1. **[Data Science Integration](../data-science/README.md)** - ML models in web apps
+2. **[Testing Strategies](../testing/README.md)** - Comprehensive testing
+3. **[API Documentation](../examples/api-documentation.md)** - OpenAPI and Swagger
+4. **[Performance Optimization](../examples/performance.md)** - Scaling web applications
+
+---
+
+**Ready to build modern web applications?** Choose your framework and start with the [practical examples](../examples/README.md).