HTTP Content Negotiation: A Developer's Guide

from flask import Flask, request, jsonify, make_response

app = Flask(__name__)

@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    # Parse Accept header
    accept = request.headers.get('Accept', '*/*')

    user_data = {
        'id': user_id,
        'name': 'Alice Johnson',
        'email': 'alice@example.com',
        'role': 'Developer'
    }

    # Content negotiation
    if 'application/json' in accept:
        return jsonify(user_data)
    elif 'text/html' in accept or 'text/plain' in accept:
        html = f"""
        <h1>User: {user_data['name']}</h1>
        <p>Email: {user_data['email']}</p>
        <p>Role: {user_data['role']}</p>
        """
        return make_response(html, 200, {'Content-Type': 'text/html'})
    elif 'application/xml' in accept:
        xml = f"""<?xml version="1.0"?>
        <user>
            <id>{user_data['id']}</id>
            <name>{user_data['name']}</name>
            <email>{user_data['email']}</email>
            <role>{user_data['role']}</role>
        </user>"""
        return make_response(xml, 200, {'Content-Type': 'application/xml'})
    else:
        return jsonify(user_data)  # Default to JSON

# Simulate requests
def simulate_request(accept_header):
    print(f"Accept: {accept_header}")
    # ... would return different formats

simulate_request("application/json")
simulate_request("text/html")
simulate_request("application/xml")

def parse_accept_header(accept_string):
    """Parse Accept header with quality values"""
    if not accept_string:
        return [('*/*', 1.0)]

    items = []
    for part in accept_string.split(','):
        part = part.strip()
        if ';q=' in part:
            media_type, q = part.split(';q=')
            items.append((media_type.strip(), float(q)))
        else:
            items.append((part, 1.0))

    # Sort by quality value, descending
    items.sort(key=lambda x: x[1], reverse=True)
    return items

# Examples
headers = [
    "text/html, application/json;q=0.9, */*;q=0.1",
    "application/json;q=0.8, text/html;q=0.5",
    "application/json, text/html",
]

for header in headers:
    parsed = parse_accept_header(header)
    print(f"Header: {header}")
    for media_type, q in parsed:
        print(f"  {media_type:25} q={q}")
    print()

LANGUAGES = {
    'en': 'Hello! Welcome to our site.',
    'fr': 'Bonjour ! Bienvenue sur notre site.',
    'es': '¡Hola! Bienvenido a nuestro sitio.',
    'de': 'Hallo! Willkommen auf unserer Seite.',
}

def negotiate_language(accept_language):
    if not accept_language:
        return 'en'

    languages = parse_accept_header(accept_language)

    for lang_tag, q in languages:
        # Extract primary language (e.g., 'fr-CH' -> 'fr')
        primary = lang_tag.split('-')[0] if '-' in lang_tag else lang_tag
        primary = primary.split(';')[0]

        if primary in LANGUAGES:
            return primary

    return 'en'  # Default

# Test
headers = [
    "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.5",
    "es-MX, es;q=0.8, en;q=0.3",
    "de-DE, de;q=0.9, en;q=0.5",
]

for header in headers:
    lang = negotiate_language(header)
    print(f"Accept-Language: {header:40} → {lang}: {LANGUAGES[lang]}")

import gzip
import zlib

def negotiate_encoding(accept_encoding):
    encodings = [e.strip() for e in accept_encoding.split(',')]

    if 'gzip' in encodings:
        return 'gzip'
    elif 'deflate' in encodings:
        return 'deflate'
    elif 'br' in encodings:
        return 'br'  # Brotli
    else:
        return 'identity'  # No compression

def compress_response(data, encoding):
    if encoding == 'gzip':
        return gzip.compress(data.encode())
    elif encoding == 'identity':
        return data.encode()
    return data.encode()

headers = ["gzip, deflate, br", "deflate", "identity"]
for header in headers:
    encoding = negotiate_encoding(header)
    data = "Hello, this is a response body that will be compressed"
    compressed = compress_response(data, encoding)
    ratio = (1 - len(compressed) / len(data)) * 100
    print(f"Accept-Encoding: {header:25} → {encoding:10} (compression: {ratio:.0f}%)")

# Implementing a versioned API with content negotiation
from enum import Enum

class APIVersion(Enum):
    V1 = "application/vnd.myapi.v1+json"
    V2 = "application/vnd.myapi.v2+json"

def get_api_version(accept):
    """Determine API version from Accept header"""
    if APIVersion.V2.value in accept:
        return 2
    elif APIVersion.V1.value in accept:
        return 1
    return 1  # Default

# Client requests:
# Accept: application/vnd.myapi.v2+json   → version 2
# Accept: application/json                → version 1 (default)

headers = [
    "application/vnd.myapi.v2+json",
    "application/json",
    "application/vnd.myapi.v1+json",
]

for header in headers:
    version = get_api_version(header)
    print(f"Accept: {header:45} → API v{version}")