Gemini vs Grok for Coding

Here is a complete, production-ready implementation of the requested FastAPI endpoint.

It utilizes Pydantic for robust input validation (ensuring only integers are accepted and limiting the size of the payload to prevent Denial of Service attacks), and includes proper error handling.

1. The Code (main.py)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import List

# Initialize the FastAPI app
app = FastAPI(
    title="Number Processor API",
    description="An API that removes duplicates and sorts a list of integers.",
    version="1.0.0"
)

# --- Pydantic Models for Validation ---

class NumbersRequest(BaseModel):
    # min_length enforces the list isn't empty.
    # max_length prevents memory exhaustion attacks (DoS).
    numbers: List[int] = Field(
        ..., 
        min_length=1, 
        max_length=10000, 
        description="A list of integers to be processed.",
        examples=[[5, 2, 9, 5, 1, 2, 8]]
    )

class NumbersResponse(BaseModel):
    original_count: int
    processed_count: int
    result: List[int]

# --- API Endpoint ---

@app.post("/api/v1/process-numbers", response_model=NumbersResponse)
async def process_numbers(payload: NumbersRequest):
    """
    Accepts a list of integers, removes duplicates, and returns them in ascending order.
    """
    try:
        # 1. Remove duplicates by converting to a Set
        unique_numbers = set(payload.numbers)
        
        # 2. Sort the unique numbers in ascending order
        sorted_numbers = sorted(unique_numbers)

        # 3. Return the payload matching the NumbersResponse model
        return {
            "original_count": len(payload.numbers),
            "processed_count": len(sorted_numbers),
            "result": sorted_numbers
        }
        
    except Exception as e:
        # Catch unexpected server-side errors
        raise HTTPException(
            status_code=500, 
            detail=f"An unexpected error occurred processing the numbers: {str(e)}"
        )

2. How to Run It

1. Install dependencies:

   pip install fastapi uvicorn
   

2. Start the server: Save the code above in a file named main.py and run:

   uvicorn main:app --reload
   

   The API will start running at http://localhost:8000.

3. How Input Validation & Error Handling Works

FastAPI automatically handles validation via the NumbersRequest Pydantic model. You don't need to manually write if type(x) != int checks.

Here are examples of how it handles different scenarios:

✅ Scenario A: Valid Input (Success)

Request:

curl -X POST "http://localhost:8000/api/v1/process-numbers" \
     -H "Content-Type: application/json" \
     -d '{"numbers": [4, 1, 4, 3, 9, 1, 5]}'

Response (200 OK):

{
  "original_count": 7,
  "processed_count": 5,
  "result": [1, 3, 4, 5, 9]
}

❌ Scenario B: Passing Strings Instead of Integers

FastAPI will automatically catch this and return a 422 Unprocessable Entity error. Request:

{"numbers": [1, 2, "apple"]}

Response (422 Unprocessable Entity):

{
  "detail": [
    {
      "type": "int_parsing",
      "loc": ["body", "numbers", 2],
      "msg": "Input should be a valid integer, unable to parse string as an integer",
      "input": "apple"
    }
  ]
}

❌ Scenario C: Empty List Sent

Because we set min_length=1 in the Pydantic Field, it rejects empty lists. Request:

{"numbers": []}

Response (422 Unprocessable Entity):

{
  "detail": [
    {
      "type": "too_short",
      "loc": ["body", "numbers"],
      "msg": "List should have at least 1 item after validation, not 0",
      "input": []
    }
  ]
}

4. Built-in Documentation

FastAPI automatically generates interactive Swagger UI documentation. While your server is running, navigate to: 👉 http://localhost:8000/docs From here, you can input data, test the endpoint visually, and see the exact schemas required.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List

app = FastAPI(title="Number Processing API", description="API to remove duplicates from a list of integers and sort them.")

class NumberList(BaseModel):
    numbers: List[int]

@app.post("/process-numbers/", response_model=dict)
async def process_numbers(data: NumberList):
    """
    Processes a list of integers:
    - Removes duplicates
    - Sorts in ascending order
    - Returns the result as JSON.
    
    Error handling:
    - Automatic validation via Pydantic (422 if invalid JSON, non-list, or non-integers).
    - Handles empty lists gracefully.
    """
    try:
        unique_sorted = sorted(set(data.numbers))
        return {"unique_sorted_numbers": unique_sorted}
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

# Optional: Root endpoint for testing
@app.get("/")
async def root():
    return {"message": "API is running. POST to /process-numbers/ with {'numbers': [1,2,2,3]}."}

# To run: uvicorn main:app --reload (save as main.py)

Usage Example

Request (POST /process-numbers/):

{
  "numbers": [3, 1, 3, 2, 1, 4]
}

Response:

{
  "unique_sorted_numbers": [1, 2, 3, 4]
}

Error Example (Invalid Input):

{
  "numbers": ["a", 1]  // Returns 422: ValidationError (not all ints)
}

Key Features

• Input Validation: Pydantic ensures numbers is a list of integers.
• Error Handling: Auto 422 for validation; 500 for unexpected errors.
• Performance: set() + sorted() is O(n log n) efficient.
• Documentation: Auto-generated OpenAPI docs at /docs.
• Run: Install deps (pip install fastapi uvicorn), then uvicorn main:app --reload.