FastAPI dependency injection Hindi

नमस्ते दोस्तों!

स्वागत है The Easy Master पर!

क्या आप FastAPI में APIs बना रहे हैं? और हर endpoint में same code baar-baar likh rahe ho? Jaise – user authentication check, database connection, logging, validation – ये सब हर बार copy-paste?

Maine bhi yeh mistake ki thi.

Jab maine pehli baar ek blog API banayi thi, toh har endpoint mein database session alag se open karta tha, user authentication check alag se likhta tha. Mera code 500 lines ka ho gaya – aur usme se 200 lines sirf repetition thi.

Toh maine Dependency Injection (DI) seekha – aur mera code 300 lines mein aa gaya, aur 10x cleaner ho gaya.

Is FastAPI dependency injection Hindi article mein main aapko sikhata hoon:

✅ Dependency Injection kya hota hai (simple words mein)
✅ Depends() ka use kaise karein
✅ Reusable dependencies – authentication, database, validation
✅ Class-based dependencies aur yield dependencies
✅ Dependency ke andar dependency – chaining
✅ Real-world examples – user auth, DB session, pagination
✅ Common mistakes aur best practices

End mein cheat sheet aur practice prompts bhi milega.

Chaliye shuru karte hain! 🚀

1. Dependency Injection Kya Hai? – Simple Example

Dependency Injection ek design pattern hai jisme aap kisi function ko uski “zarooratein” (dependencies) bahar se provide karte ho, function khud create nahi karta.

Bina DI ke (tight coupling):

Code

def get_user_data(user_id):
    # Function khud database connection banata hai
    db = Database.connect()  # hardcoded
    return db.query(user_id)

Problem – function specific database pe dependent hai. Test karna mushkil.

DI ke saath (loose coupling):

Code

def get_user_data(user_id, db: Database):
    # Database dependency bahar se aati hai
    return db.query(user_id)

FastAPI mein DI ka matlab:
Aap ek dependency function banate ho – jo kuch bhi return kare (e.g., database session, current user, validation result). Phir endpoint mein Depends(dependency_function) use karke FastAPI ko batate ho – “yeh cheez pehle run karo aur result mujhe do”.

FastAPI automatically dependency ko call karega, result compute karega, aur aapke endpoint function mein pass kar dega.

2. FastAPI Mein Pehla Dependency

Chaliye ek simple dependency banatein – jo common query parameters handle kare:

Code

from fastapi import FastAPI, Depends, Query
from typing import Optional

app = FastAPI()

# Dependency function
def common_parameters(
    skip: int = Query(0, ge=0),
    limit: int = Query(10, ge=1, le=100),
    q: Optional[str] = None
):
    # Ye function ek dict return karega
    return {"skip": skip, "limit": limit, "q": q}

# Endpoint jo dependency use karta hai
@app.get("/items/")
def list_items(params: dict = Depends(common_parameters)):
    # params mein skip, limit, q aayega
    return {
        "message": "Items list",
        "params": params
    }

@app.get("/users/")
def list_users(params: dict = Depends(common_parameters)):
    # Same dependency, same logic!
    return {
        "message": "Users list",
        "params": params
    }

Kya ho raha hai?

common_parameters ek dependency hai – query parameters parse karti hai.
/items/ aur /users/ dono same dependency use kar rahe hain.
Code duplicate nahi karna pada – 2 lines mein kaam ho gaya.

Aur bhi simple – direct access to individual values:

Code

def common_params(
    skip: int = Query(0, ge=0),
    limit: int = Query(10, ge=1, le=100)
):
    return (skip, limit)  # tuple return

@app.get("/products/")
def get_products(
    skip: int = Depends(lambda: 0),  # inline dependency
    limit: int = Depends(lambda: 10),
    params: tuple = Depends(common_params)
):
    return {"skip": skip, "limit": limit}

3. Common Use Cases – Real World Problems

3.1 Authentication Check – JWT Token Verify

Code

from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials

security = HTTPBearer()

# Dependency: verify token and return user
def get_current_user(
    credentials: HTTPAuthorizationCredentials = Depends(security)
):
    token = credentials.credentials
    try:
        # Verify JWT token (pseudo code)
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        user_id = payload.get("sub")
        if not user_id:
            raise HTTPException(status_code=401, detail="Invalid token")
        return {"id": user_id, "username": "example"}
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

# Endpoint protected by dependency
@app.get("/profile/")
def get_profile(current_user: dict = Depends(get_current_user)):
    return {"user": current_user}

3.2 Database Session – SQLAlchemy

Code

from fastapi import Depends
from sqlalchemy.orm import Session

# Dependency: create and yield session
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/users/")
def create_user(user_data: UserCreate, db: Session = Depends(get_db)):
    # db session automatically available
    db_user = User(**user_data.dict())
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

3.3 Pagination Dependency – Reusable

Code

from pydantic import BaseModel
from fastapi import Depends, Query

class Pagination(BaseModel):
    skip: int = Query(0, ge=0)
    limit: int = Query(10, ge=1, le=100)

def pagination_params(p: Pagination = Depends()) -> Pagination:
    return p

@app.get("/posts/")
def list_posts(pagination: Pagination = Depends(pagination_params)):
    # Use pagination.skip, pagination.limit
    return {"skip": pagination.skip, "limit": pagination.limit}

Personal Experience: Maine ek baar 10 different endpoints mein pagination code copy-paste kiya. Phir jab limit badalni thi, toh 10 jagah change karni padi. Dependency injection use karta toh ek jagah change karta – kaam ho jata. Us din DI ka importance samajh aaya.

4. Dependency Ke Andar Dependency – Chaining

FastAPI mein dependencies doosre dependencies ko call kar sakti hain. Isse code modular rehta hai.

Example: Authentication → User Permission → Database

Code

from fastapi import Depends, HTTPException

# Level 1: Get user from token
def get_current_user(token: str = Depends(oauth2_scheme)):
    # ... return user object
    return {"id": 1, "role": "admin"}

# Level 2: Check permission using user from level 1
def get_admin_user(current_user: dict = Depends(get_current_user)):
    if current_user["role"] != "admin":
        raise HTTPException(status_code=403, detail="Admin only")
    return current_user

# Level 3: Get DB session using user (but session independent)
def get_db_session(current_user: dict = Depends(get_current_user)):
    # can use current_user info to choose DB
    db = get_database_for_user(current_user["id"])
    try:
        yield db
    finally:
        db.close()

# Endpoint uses admin check + db
@app.get("/admin/reports/")
def get_report(
    admin: dict = Depends(get_admin_user),
    db = Depends(get_db_session)
):
    return {"report": "sensitive data"}

FastAPI automatically resolve karega – pehle get_current_user chalega, then get_admin_user, then endpoint.

5. Class-Based Dependencies

Kai baar stateful dependency chahiye – tab class use karo. FastAPI class instance ko dependency ki tarah treat kar sakta hai.

Code

from fastapi import Depends

class Pagination:
    def __init__(self, default_limit: int = 10):
        self.default_limit = default_limit

    def __call__(self, skip: int = Query(0), limit: int = Query(self.default_limit)):
        return {"skip": skip, "limit": limit}

# Create instance
pagination = Pagination(default_limit=20)

@app.get("/items/")
def list_items(p: dict = Depends(pagination)):
    return p

Simpler way – class as dependency directly:

Code

class CommonParams:
    def __init__(self, skip: int = Query(0), limit: int = Query(10)):
        self.skip = skip
        self.limit = limit

@app.get("/data/")
def get_data(params: CommonParams = Depends()):
    return {"skip": params.skip, "limit": params.limit}

FastAPI automatically CommonParams(skip=..., limit=...) call karega.

6. Yield Dependencies – Cleanup Ke Liye

Jab aapko resource cleanup karna ho (e.g., close database connection), yield ka use karo. FastAPI yield ke baad ka code endpoint ke baad chalayega.

Code

from fastapi import Depends
from contextlib import contextmanager

def get_db():
    db = Database.connect()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/")
def get_users(db = Depends(get_db)):
    # db session open
    return db.query("SELECT * FROM users")
    # db automatically close after response

Multiple yields – dependencies can call other yield dependencies:

Code

def get_transaction(db = Depends(get_db)):
    transaction = db.begin()
    try:
        yield transaction
        transaction.commit()
    except Exception:
        transaction.rollback()
        raise

7. Global vs Local Dependencies

Global Dependency – Sabhi endpoints par apply

Code

app = FastAPI(dependencies=[Depends(log_request)])

def log_request():
    print("Request received")
    # no return needed

# Sabhi routes par log_request automatically run hoga
@app.get("/")
def home(): ...

Router-level Dependency – Specific group ke liye

Code

from fastapi import APIRouter

admin_router = APIRouter(dependencies=[Depends(verify_admin)])

@admin_router.get("/stats/")
def stats():  # automatically admin check
    pass

Endpoint-level Dependency – Sirf ek endpoint ke liye

Code

@app.get("/profile/", dependencies=[Depends(verify_token)])
def profile():
    pass

8. Real Project Example – Complete API

Ek mini blog API banate hain jo dependency injection ka full use kare:

Code

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel
from typing import Optional, List
import jwt

app = FastAPI(title="Blog API")
security = HTTPBearer()
SECRET_KEY = "secret"
ALGORITHM = "HS256"

# ---------- Models ----------
class PostCreate(BaseModel):
    title: str
    content: str

class PostOut(BaseModel):
    id: int
    title: str
    author: str

# ---------- Dependencies ----------
def get_current_user(token: HTTPAuthorizationCredentials = Depends(security)):
    try:
        payload = jwt.decode(token.credentials, SECRET_KEY, algorithms=[ALGORITHM])
        username = payload.get("sub")
        if not username:
            raise HTTPException(status_code=401)
        return {"username": username}
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

def require_admin(current_user = Depends(get_current_user)):
    if current_user["username"] != "admin":
        raise HTTPException(status_code=403)
    return current_user

def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

# In-memory DB
posts_db = []
post_id_counter = 1

# ---------- Endpoints ----------
@app.post("/posts/", response_model=PostOut)
def create_post(
    post: PostCreate,
    current_user = Depends(get_current_user)  # any logged-in user
):
    global post_id_counter
    new_post = {
        "id": post_id_counter,
        "title": post.title,
        "content": post.content,
        "author": current_user["username"]
    }
    posts_db.append(new_post)
    post_id_counter += 1
    return new_post

@app.get("/posts/")
def list_posts(
    pagination: dict = Depends(pagination),
    current_user = Depends(get_current_user)  # optional but logged-in required
):
    skip = pagination["skip"]
    limit = pagination["limit"]
    return posts_db[skip:skip+limit]

@app.delete("/posts/{post_id}")
def delete_post(
    post_id: int,
    _ = Depends(require_admin)  # only admin
):
    global posts_db
    posts_db = [p for p in posts_db if p["id"] != post_id]
    return {"message": "Deleted"}

9. Common Mistakes (aur Unka Solution!)

Mistake	Why?	Solution
Dependency mein `yield` ke baad return karna	`yield` wali function generator ban jati hai, return invalid	`yield` dependencies sirf yield karein, return nahi
`Depends()` bhoolna	Dependency function ko direct call kar dete ho	Always use `Depends(dependency)`
Circular dependencies	A depends on B, B depends on A	Refactor code – extract common dependency
Dependency mein heavy computation	Har request pe heavy task	Cache result ya use `lru_cache`
Type hint na dena	FastAPI inference galat ho sakta hai	Hamesha type hints do: `db: Session = Depends(get_db)`
Default value `Depends()` mein parameter ke saath	`param = Depends(func)` is special syntax	`Depends` ka use sirf default value position mein karo, optional banana hai toh `Optional[type] = Depends(func)`

Personal Mistake: Maine ek baar dependency function mein return ke baad yield likh diya – FastAPI ne error diya. Phir samajh aaya ki yield wali functions generator hoti hain, unme return nahi use kar sakte.

10. Best Practices – Professional Code Likho

Single Responsibility: Ek dependency ek kaam kare – authentication, ya DB session, ya validation.

Type Hints zaroor do: def get_user(token: str = Depends(oauth)) -> User:

Error handling: Dependencies mein HTTPException raise karo – FastAPI automatically handle karega.

Caching for expensive deps:

Python

from functools import lru_cache

@lru_cache
def get_settings():
    return Settings()

Use Annotated for cleaner code (Python 3.9+):

Code

from typing import Annotated

DbDep = Annotated[Session, Depends(get_db)]
UserDep = Annotated[dict, Depends(get_current_user)]

@app.get("/profile/")
def profile(current_user: UserDep, db: DbDep):
    ...

Dependencies ko separate file mein rakho – dependencies.py

Document dependencies – docstring likho ki kya return karti hai

11. Resources – Cheat Sheet aur Practice Prompts

Cheat Sheet (Copy-Paste)

Code

# Basic dependency
def common(q: str = None):
    return q

@app.get("/")
def endpoint(param = Depends(common)):
    pass

# Yield dependency (cleanup)
def get_db():
    db = connect()
    try:
        yield db
    finally:
        db.close()

# Dependency chaining
def get_user(token=Depends(oauth)):
    return user

def get_admin(user=Depends(get_user)):
    if user.role != "admin": raise HTTPException(403)
    return user

# Class dependency
class Pagination:
    def __init__(self, limit: int = 10):
        self.limit = limit

@app.get("/")
def list(p: Pagination = Depends()):
    return p.limit

# Global dependency
app = FastAPI(dependencies=[Depends(log_middleware)])

Practice Prompts

Beginner: Ek dependency banao jo request ke time ko measure kare aur print kare. Har endpoint mein use karo.
Intermediate: Ek get_current_organization dependency banao jo user token se organization ID nikaale. Fir ek require_org_member dependency banao jo check kare ki user us organization ka member hai ya nahi.
Advanced: Ek caching dependency banao – jo same arguments ke liye result cache kare (use lru_cache). Endpoint ke saath use karke check karo ki second request fast aati hai.

12. FAQ

Q1: Dependency injection aur normal function call mein kya antar hai?

Dependency injection mein FastAPI automatically dependency resolve karta hai, caching manage karta hai, aur nested dependencies handle karta hai. Normal call mein aapko sab manually karna padta hai.

Q2: Kya dependencies asynchronous ho sakti hain?

Haan! async def get_db() bhi likh sakte ho. FastAPI async aur sync dono support karta hai.

Q3: Ek endpoint mein kitni dependencies use kar sakte hain?

Unlimited. FastAPI sabko parallel execute karega jahan possible ho.

Q4: Dependency ka result cache hota hai?

Haan – same request mein same dependency multiple baar call hoti hai toh FastAPI cached result reuse karega. But alag requests mein caching nahi hoti – uske liye external cache (Redis) chahiye.

Q5: Depends() ko default argument ki jagah kaise use karu bina default ke?

param: type = Depends(func) – ye required dependency hai. Optional ke liye param: Optional[type] = Depends(func).

Q6: Kya dependency endpoint ke path parameters access kar sakti hai?

Haan – agar endpoint path parameter hai /{item_id}, toh dependency mein same name ka parameter declare karo: def dep(item_id: int): – FastAPI automatically pass karega.

Q7: Testing mein dependencies ko mock kaise karein?

FastAPI provides app.dependency_overrides – jisse aap test ke time fake dependency replace kar sakte ho.

Code

app.dependency_overrides[get_current_user] = lambda: {"test_user": "mock"}

13. Conclusion – Ab Aapki Baari!

Bahut badhiya! Aapne aaj seekh liya:

✅ FastAPI dependency injection Hindi mein – Depends() ka power
✅ Reusable authentication, database, pagination dependencies
✅ Chaining, yield cleanup, class-based dependencies
✅ Real project example aur best practices

Dependency injection code ko DRY (Don’t Repeat Yourself) banata hai. Ab aap clean, maintainable, testable APIs likh sakte ho.

Aapki aaj ki challenge:
Upar diye practice prompts mein se koi ek implement karo. Apna code comment mein share karo – main review karunga.

Next topic kya chahiye?

FastAPI WebSockets (Real-time chat)?
FastAPI Background Tasks?
FastAPI Testing (pytest)?

Comment mein batado!

The Easy Master ke saath smart coding karte raho. Happy depending! 🚀

Resources

Additional Resources

4. FastAPI dependency injection Hindi – Code Reuse Ka Magic

Table of Contents

1. Dependency Injection Kya Hai? – Simple Example

2. FastAPI Mein Pehla Dependency

3. Common Use Cases – Real World Problems

3.1 Authentication Check – JWT Token Verify

3.2 Database Session – SQLAlchemy

4. Dependency Ke Andar Dependency – Chaining

5. Class-Based Dependencies

6. Yield Dependencies – Cleanup Ke Liye

7. Global vs Local Dependencies

Global Dependency – Sabhi endpoints par apply

Router-level Dependency – Specific group ke liye

Endpoint-level Dependency – Sirf ek endpoint ke liye

8. Real Project Example – Complete API

9. Common Mistakes (aur Unka Solution!)

10. Best Practices – Professional Code Likho

11. Resources – Cheat Sheet aur Practice Prompts

Cheat Sheet (Copy-Paste)

Practice Prompts

12. FAQ

13. Conclusion – Ab Aapki Baari!

Resources

Additional Resources

Related posts

2. FastAPI Path Parameters Hindi – शून्य से हीरो तक गाइड 2026

1. FastAPI Kya Hai? FastAPI Python Setup Aur Pehla API Hindi 2026

10. FastAPI Deployment Hindi – Railway Zero to Hero 2026

Leave a Reply Cancel reply