FastAPI தானியங்கி ஆவணமாக்கத்தை எவ்வாறு உருவாக்குகிறது?

Question

Accepted Answer

FastAPI உங்கள் code-இலிருந்து **interactive API documentation-ஐ தானாகவே உருவாக்குகிறது** — உங்கள் routes, parameters, மற்றும் Pydantic models ஆகியவை ஒரு OpenAPI schema-ஆக மாற்றப்படுகின்றன, இது கூடுதல் முயற்சி எதுவும் இல்லாமல் இரண்டு browsable doc UI-களை (Swagger UI மற்றும் ReDoc) இயக்குகிறது.

## உங்களுக்கு docs இலவசமாகக் கிடைக்கிறது

```python
class Item(BaseModel):
    name: str
    price: float = Field(gt=0, description="Price in USD")

@app.post("/items", tags=["items"], summary="Create an item")
def create_item(item: Item):
    """Create a new item with a name and price."""   # docstring → endpoint description
    return item
```

typed endpoints மற்றும் models எழுதுவதன் மூலமே, FastAPI முழுமையான docs-ஐ உருவாக்குகிறது — எழுதவோ பராமரிக்கவோ தனி documentation file எதுவும் தேவையில்லை.

## இரண்டு உள்ளமைந்த doc UI-கள்

```text
/docs   → Swagger UI — interactive: browse endpoints AND test them in the browser
          (fill in parameters, send requests, see responses live)
/redoc  → ReDoc — a clean, readable reference-style view
/openapi.json → the raw OpenAPI schema (usable to generate client SDKs, etc.)
```

`/docs`-ஐ பார்வையிட்டால், ஒவ்வொரு endpoint-ஐயும் ஆராயலாம், தேவையான parameters மற்றும் response வடிவங்களைப் பார்க்கலாம், மேலும் browser-இலிருந்து நேரடியாக **உண்மையான requests அனுப்பலாம்** — development-இன் போதும் API consumers-க்கும் இது மிகவும் மதிப்புமிக்கது.

## doc உள்ளடக்கம் எங்கிருந்து வருகிறது

```text
Route decorators → paths, HTTP methods, tags, summaries
Type hints       → parameter types, required/optional
Pydantic models  → request/response schemas, field constraints & descriptions
Docstrings       → endpoint descriptions
Field(..., description=, example=) → field-level docs and examples
```

எல்லாமே நீங்கள் ஏற்கனவே எழுதும் code-இலிருந்து பெறப்படுகிறது — docs எப்போதும் implementation-உடன் தானாகவே **ஒத்திசைவாக** இருக்கின்றன.

## docs-ஐ வளப்படுத்துதல்

```python
app = FastAPI(title="My API", version="1.0", description="...")
@app.get("/x", response_model=Item, responses={404: {"description": "Not found"}})
```

## இது ஏன் முக்கியம்

தானியங்கி interactive documentation FastAPI-இன் மிகவும் பாராட்டப்படும் அம்சங்களில் ஒன்றாகும், மேலும் அதன் புகழுக்கு ஒரு முக்கிய காரணமாகும்.

docs உங்கள் code-இலிருந்து நேரடியாக (routes, type hints, Pydantic models, docstrings) உருவாக்கப்படுவதால், அவை எப்போதும் உண்மையான implementation-உடன் **ஒத்திசைவாக** இருக்கின்றன — கையால் எழுதப்படும் docs-ஐ வாட்டும், காலாவதியாகி விடும் என்ற நாள்பட்ட பிரச்சினையை இது நீக்குகிறது.

interactive Swagger UI (`/docs`) developers மற்றும் API consumers-ஐ **browser-இல் endpoints-ஐ நேரலையில் ஆராயவும் test செய்யவும்** அனுமதிக்கிறது, இது developer experience-ஐ வியத்தகு அளவில் மேம்படுத்துகிறது மற்றும் integration friction-ஐக் குறைக்கிறது.

உருவாக்கப்படும் OpenAPI schema, client SDK generation மற்றும் contract testing-ஐயும் இயக்க முடியும்.

நன்கு typed செய்யப்பட்ட code எழுதுவதன் மூலம் மட்டுமே — தொழில்முறை, துல்லியமான, interactive API docs-ஐ அடிப்படையில் இலவசமாகப் பெறுவது ஒரு குறிப்பிடத்தக்க productivity மற்றும் quality வெற்றியாகும், இது இதை ஒரு முக்கியமான, தனித்துவமான FastAPI திறனாக மாற்றுகிறது.