# FastAPI Form

***

**1. Basic form data retrieval:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(...)):
    return {"name": name}
```

**2. Multiple field form data retrieval:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(...), age: int = Form(...)):
    return {"name": name, "age": age}
```

**3. Optional field form data retrieval:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(None), age: int = Form(None)):
    return {"name": name, "age": age}
```

**4. Default value for optional field:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form("John Doe", min_length=1)):
    return {"name": name}
```

**5. Validation for optional field:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(None, min_length=1)):
    return {"name": name}
```

**6. List of values:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(names: list[str] = Form(...)):
    return {"names": names}
```

**7. Dictionary of values:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(data: dict[str, str] = Form(...)):
    return {"data": data}
```

**8. Arbitrary value:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(data: Any = Form(...)):
    return {"data": data}
```

**9. Custom conversion:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(date: datetime = Form(..., converter=parse_datetime)):
    return {"date": date}
```

**10. Validation error response:**

```python
from fastapi import Form, HTTPException

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(..., min_length=1)):
    if len(name) < 1:
        raise HTTPException(status_code=400, detail="Name must be at least 1 character long.")
    return {"name": name}
```

**11. Form field metadata:**

```python
from fastapi import Form

app = FastAPI()

@app.post("/form")
async def form_data(name: Form = Form(...)):
    print(name.field_info)  # FieldInfo instance containing metadata
```

**12. Form fields as a class:**

```python
from fastapi.encoders import jsonable_encoder
from fastapi import Form

app = FastAPI()

class FormData:
    name: str
    age: int

@app.post("/form")
async def form_data(data: FormData = Form(...)):
    return jsonable_encoder(data)
```

**13. Handling multipart/form-data (file upload):**

```python
from fastapi import File, Form

app = FastAPI()

@app.post("/form")
async def form_data(file: bytes = File(...), name: str = Form(...)):
    return {"file": file, "name": name}
```

**14. Custom file conversion:**

```python
from fastapi import File

app = FastAPI()

@app.post("/form")
async def form_data(file: bytes = File(..., converter=convert_to_image)):
    return {"image": file}
```

**15. File validation:**

```python
from fastapi import File, HTTPException

app = FastAPI()

@app.post("/form")
async def form_data(file: bytes = File(...)):
    if not file.content_type.startswith("image/"):
        raise HTTPException(status_code=400, detail="Invalid file type.")
    return {"file": file}
```

**16. Multiple files:**

```python
from fastapi import File

app = FastAPI()

@app.post("/form")
async def form_data(files: list[bytes] = File(...)):
    return {"files": files}
```

**17. File and field data together:**

```python
from fastapi import File, Form

app = FastAPI()

@app.post("/form")
async def form_data(file: bytes = File(...), name: str = Form(...)):
    return {"file": file, "name": name}
```

**18. Request body as a string:**

```python
from fastapi import Request

app = FastAPI()

@app.post("/form")
async def form_data(request: Request):
    body = await request.body()
    return {"body": body}
```

**19. Using a Pydantic model to validate form data:**

```python
from fastapi import Form, HTTPException
from pydantic import BaseModel

app = FastAPI()

class FormData(BaseModel):
    name: str
    age: int

@app.post("/form")
async def form_data(data: FormData = Form(...)):
    if not data.is_valid():
        raise HTTPException(status_code=400, detail="Invalid data.")
    return {"data": data}
```

**20. Using a custom Form model to validate form data:**

```python
from fastapi.encoders import jsonable_encoder
from fastapi import Form

app = FastAPI()

class FormData:
    name: str
    age: int

    @classmethod
    async def __form__(cls, data: dict[str, Any] = None):
        if data is None or "name" not in data or "age" not in data:
            raise HTTPException(status_code=400, detail="Invalid data.")
        return jsonable_encoder(cls(**data))

@app.post("/form")
async def form_data(data: FormData = Form(...)):
    return {"data": data}
```

**21. Using a FormField to validate individual form fields:**

```python
from fastapi import Field, FormField

app = FastAPI()

@app.post("/form")
async def form_data(name: str = FormField(..., min_length=1)):
    return {"name": name}
```

**22. Using a FormField to add validation to existing Form parameters:**

```python
from fastapi import Form, FormField

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(..., min_length=1)):
    return {"name": name}

@app.post("/form-with-field")
async def form_data_with_field(name: str = FormField(name, min_length=1)):
    return {"name": name}
```

**23. Using a FormField to control field behavior:**

```python
from fastapi import Field, FormField

app = FastAPI()

@app.post("/form")
async def form_data(name: str = FormField(..., alias="user_name")):
    return {"name": name}
```

**24. Using a FormField to perform dependency injection:**

```python
from fastapi import Depends, FormField

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Depends(FormField(...))):
    return {"name": name}
```

**25. Using a FormField to customize field metadata:**

```python
from fastapi import Field, FormField

app = FastAPI()

@app.post("/form")
async def form_data(name: str = FormField(..., description="The user's name.")):
    return {"name": name}
```

**26. Using a FormParameter to validate individual form fields:**

```python
from fastapi import FormParameter

app = FastAPI()

@app.post("/form")
async def form_data(name: str = FormParameter(..., min_length=1)):
    return {"name": name}
```

**27. Using a FormParameter to add validation to existing Form parameters:**

```python
from fastapi import Form, FormParameter

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(..., min_length=1)):
    return {"name": name}

@app.post("/form-with-parameter")
async def form_data_with_parameter(name: str = FormParameter(name, min_length=1)):
    return {"name": name}
```

**28. Using a FormParameter to control field behavior:**

```python
from fastapi import Field, FormParameter

app = FastAPI()

@app.post("/form")
async def form_data(name: str = FormParameter(..., alias="user_name")):
    return {"name": name}
```

**29. Using a FormParameter to perform dependency injection:**

```python
from fastapi import Depends, FormParameter

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Depends(FormParameter(...))):
    return {"name": name}
```

**30. Using a FormParameter to customize field metadata:**

```python
from fastapi import Field, FormParameter

app = FastAPI()

@app.post("/form")
async def form_data(name: str = FormParameter(..., description="The user's name.")):
    return {"name": name}
```

**31. Using a query parameter and a form parameter together:**

```python
from fastapi import Form, Query

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(...), age: int = Query(...)):
    return {"name": name, "age": age}
```

**32. Using a path parameter and a form parameter together:**

```python
from fastapi import Form, Path

app = FastAPI()

@app.post("/form/{user_id}")
async def form_data(name: str = Form(...), user_id: int = Path(...)):
    return {"name": name, "user_id": user_id}
```

**33. Using a header parameter and a form parameter together:**

```python
from fastapi import Form, Header

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(...), token: str = Header(...)):
    return {"name": name, "token": token}
```

**34. Using a cookie parameter and a form parameter together:**

```python
from fastapi import Form, Cookie

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(...), session_id: str = Cookie(...)):
    return {"name": name, "session_id": session_id}
```

**35. Using a request body as a string and a form parameter together:**

```python
from fastapi import Form, Request

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(...), request: Request):
    body = await request.body()
    return {"name": name, "body": body}
```

**36. Using a request object and a form parameter together:**

```python
from fastapi import Form, Request

app = FastAPI()

@app.post("/form")
async def form_data(name: str = Form(...), request: Request):
    client_ip = request.client.host
    return {"name": name, "client_ip": client_ip}
```