ChatGPT vs Perplexity for Coding

Here’s a clean FastAPI example that:

• accepts a JSON payload
• validates it with Pydantic
• filters the response
• includes error handling
• uses type hints

from typing import List, Optional

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field, EmailStr, ValidationError

app = FastAPI()


# Request schema
class UserInput(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    age: int = Field(..., ge=0, le=120)
    email: EmailStr
    tags: List[str] = Field(default_factory=list)
    is_active: bool = True


# Response schema
class UserResponse(BaseModel):
    name: str
    email: EmailStr
    tags: List[str]


@app.exception_handler(ValidationError)
async def pydantic_validation_exception_handler(
    request: Request, exc: ValidationError
) -> JSONResponse:
    return JSONResponse(
        status_code=422,
        content={
            "error": "Validation failed",
            "details": exc.errors(),
        },
    )


@app.post("/users/filter", response_model=UserResponse)
async def filter_user(payload: UserInput) -> UserResponse:
    try:
        if payload.age < 18:
            raise HTTPException(
                status_code=400,
                detail="User must be at least 18 years old"
            )

        filtered_tags: List[str] = [tag for tag in payload.tags if tag.strip()]

        return UserResponse(
            name=payload.name,
            email=payload.email,
            tags=filtered_tags,
        )

    except HTTPException:
        raise
    except Exception as exc:
        raise HTTPException(
            status_code=500,
            detail=f"Internal server error: {str(exc)}"
        )

Example request

POST /users/filter

{
  "name": "Alice",
  "age": 25,
  "email": "alice@example.com",
  "tags": ["admin", "", "user"],
  "is_active": true
}

Example response

{
  "name": "Alice",
  "email": "alice@example.com",
  "tags": ["admin", "user"]
}

Run it

Install dependencies:

pip install fastapi uvicorn pydantic[email]

Start the server:

uvicorn main:app --reload

Docs will be available at:

• http://127.0.0.1:8000/docs

If you want, I can also provide:

1. a version with stricter custom validators,
2. a production-style folder structure,
3. or unit tests for this endpoint.

Here's a complete FastAPI REST API endpoint that accepts a JSON payload, validates it with Pydantic, filters the response, and includes comprehensive error handling:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field, validator
from typing import List, Optional
from enum import Enum

app = FastAPI(title="Filtered API Example", version="1.0.0")

# Enum for filtering options
class FilterType(str, Enum):
    name = "name"
    category = "category"
    price_high = "price_high"
    price_low = "price_low"

# Pydantic model for input validation
class ProductCreate(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    description: str = Field(..., min_length=10, max_length=500)
    category: str = Field(..., min_length=1, max_length=50)
    price: float = Field(..., gt=0, le=10000)
    in_stock: bool = True
    tags: Optional[List[str]] = []

    @validator('name')
    def name_must_not_be_empty(cls, v):
        if not v.strip():
            raise ValueError('Name cannot be empty or whitespace only')
        return v.strip()

# Pydantic model for filtered response
class ProductResponse(BaseModel):
    name: str
    category: str
    price: float
    in_stock: bool

# In-memory database (replace with real DB in production)
products_db: List[ProductCreate] = []

@app.post("/products/", response_model=List[ProductResponse], status_code=200)
async def create_and_filter_products(
    products: List[ProductCreate],
    filter_by: Optional[FilterType] = None,
    filter_value: Optional[str] = None,
    min_price: Optional[float] = None,
    max_price: Optional[float] = None
):
    """
    Create multiple products and return filtered response.
    
    - **products**: List of products to create
    - **filter_by**: Filter by 'name', 'category', 'price_high', or 'price_low'
    - **filter_value**: Value to filter by (for name/category)
    - **min_price/max_price**: Price range filter
    """
    if not products:
        raise HTTPException(
            status_code=400, 
            detail="At least one product is required"
        )
    
    try:
        # Add products to database
        created_products = []
        for product in products:
            products_db.append(product)
            created_products.append(product)
        
        # Apply filtering logic
        filtered_products = _filter_products(
            products=created_products,
            filter_by=filter_by,
            filter_value=filter_value,
            min_price=min_price,
            max_price=max_price
        )
        
        if not filtered_products:
            raise HTTPException(
                status_code=404, 
                detail="No products match the filter criteria"
            )
        
        return filtered_products
    
    except ValueError as e:
        raise HTTPException(status_code=422, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail="Internal server error")

def _filter_products(
    products: List[ProductCreate],
    filter_by: Optional[FilterType],
    filter_value: Optional[str],
    min_price: Optional[float],
    max_price: Optional[float]
) -> List[ProductResponse]:
    """Internal filtering logic"""
    filtered = []
    
    for product in products:
        matches = True
        
        # Filter by specific field
        if filter_by:
            if filter_by == FilterType.name and filter_value:
                matches = filter_value.lower() in product.name.lower()
            elif filter_by == FilterType.category and filter_value:
                matches = filter_value.lower() in product.category.lower()
            elif filter_by == FilterType.price_high and filter_value:
                try:
                    target_price = float(filter_value)
                    matches = product.price >= target_price
                except ValueError:
                    continue
            elif filter_by == FilterType.price_low and filter_value:
                try:
                    target_price = float(filter_value)
                    matches = product.price <= target_price
                except ValueError:
                    continue
        
        # Price range filter
        if matches and min_price is not None and product.price < min_price:
            matches = False
        if matches and max_price is not None and product.price > max_price:
            matches = False
        
        if matches:
            filtered.append(ProductResponse(
                name=product.name,
                category=product.category,
                price=product.price,
                in_stock=product.in_stock
            ))
    
    return filtered

# Health check endpoint
@app.get("/health")
async def health_check():
    return {"status": "healthy", "products_count": len(products_db)}

# Run with: uvicorn main:app --reload

Key Features Demonstrated:

1. JSON Payload Validation: Pydantic ProductCreate model with field constraints, custom validators, and type hints[1][2]

2. Filtered Response: ProductResponse model returns only essential fields (name, category, price, stock)[1]

3. Query Parameters: Flexible filtering with filter_by, filter_value, min_price, max_price using enums and optionals[1]

4. Error Handling:

   • HTTPException for 400 (bad request), 404 (not found), 422 (validation), 500 (server error)[1]
   • Custom validation errors with clear messages[2]

5. Type Safety: Full type hints throughout with async/await support[2]

Example Usage:

Request:

curl -X POST "http://localhost:8000/products/?filter_by=category&filter_value=electronics&min_price=50" \
-H "Content-Type: application/json" \
-d '[  {
    "name": "iPhone 15",
    "description": "Latest smartphone model",
    "category": "electronics",
    "price": 999.99,
    "in_stock": true,
    "tags": ["apple", "smartphone"]
  },
  {
    "name": "Laptop Pro",
    "description": "High-performance laptop",
    "category": "electronics",
    "price": 1499.99,
    "in_stock": false
  }
]'

Response:

[  {
    "name": "iPhone 15",
    "category": "electronics",
    "price": 999.99,
    "in_stock": true
  }
]

To Run:

pip install fastapi uvicorn pydantic[email protected]
uvicorn main:app --reload

Visit http://localhost:8000/docs for interactive Swagger UI with auto-generated schema and testing interface.[1][2][3]