async def र def कहिले endpoint को लागि प्रयोग गर्नुपर्छ?

Question

Accepted Answer

FastAPI ले `async def` र नियमित `def` दुबै path operations को लागि समर्थन गर्छ। यो विकल्प कार्यक्षमताको लागि महत्त्वपूर्ण छ: non-blocking I/O `await` गर्न सक्ने बेला **`async def`** प्रयोग गर्नुहोस्, र तपाईंको कोडले blocking (synchronous) operations गर्ने बेला नियमित **`def`** प्रयोग गर्नुहोस्।

## दुवै रूप

```python
@app.get("/async")
async def async_endpoint():
    data = await fetch_from_api()        # await non-blocking I/O — efficient
    return data

@app.get("/sync")
def sync_endpoint():
    data = blocking_db_call()             # ordinary blocking code
    return data
```

## FastAPI ले प्रत्येकलाई कसरी सम्भाल्छ

```text
async def → runs on the main event loop. Efficient ONLY if you await non-blocking calls.
            ⚠️ A BLOCKING call inside async def blocks the WHOLE event loop → kills concurrency!
def       → FastAPI runs it in a THREAD POOL, so blocking code doesn't block the event loop.
            Safe for synchronous/blocking libraries.
```

## निर्णय नियम

```python
# ✅ async def — when you can await async libraries (httpx, async DB drivers)
async def get_user():
    async with httpx.AsyncClient() as c:
        return await c.get(url)

# ✅ plain def — when using SYNCHRONOUS/blocking libraries (requests, sync ORM)
def get_user():
    return requests.get(url).json()       # blocking → FastAPI runs it in a thread

# ❌ THE DANGEROUS MISTAKE — blocking call inside async def
async def bad():
    return requests.get(url).json()       # blocks the event loop! Use `def` or an async client
```

विमोचक नियम: **कहिले पनि `async def` मा blocking calls राख्नुहोस्** — यो event loop लाई block गर्छ र concurrency लाई नष्ट गर्छ। या `await` संग async library प्रयोग गर्नुहोस्, वा सादा `def` प्रयोग गर्नुहोस् (जसलाई FastAPI सुरक्षितरूपले thread pool मा चलाउछ)।

## यसको महत्व किन छ

`async def` र `def` बीच सही विकल्प गर्नु तपाईंको API को कार्यक्षमता र concurrency लाई सीधा असर गर्छ, र यो गलत गर्नु एक सामान्य, गम्भीर गल्ती हो।

मुख्य अन्तर्दृष्टि यो हो कि **`async def` केवल लाभजनक हुन्छ जब तपाई non-blocking operations `await` गर्नुहुन्छ** — एक blocking call (जस्तै synchronous `requests` library वा blocking database driver) `async def` भित्र राख्दा सम्पूर्ण event loop लाई block गर्छ, सबै concurrent requests लाई फ्रीज गर्छ र async को उद्देश्य लाई नष्ट गर्छ।

उल्टो, FastAPI ले सादा `def` endpoints लाई thread pool मा चलाउछ, त्यसैले synchronous/blocking कोड त्यहाँ सुरक्षित छ।

यो नियम बुझ्नु — `async def` साँच्चै async libraries संग प्रयोग गर्नुहोस्, blocking कोडको लागि सादा `def` प्रयोग गर्नुहोस्, र कहिले पनि blocking calls लाई `async def` मा मिसाउनु हुँदैन — यो performant FastAPI endpoints लेख्न र एक सूक्ष्म तर विनाशकारी गल्ती बचाउन आवश्यक छ कि सबै requests लाई एक blocked event loop पछाडि accidentally serialize गर्ने।