Basic Depends ઈતર, FastAPI નો dependency injection આ advanced patterns સપોર્ટ કરે છે: sub-dependencies, dependencies with parameters (class-based અથવા factories વિધેય), scoped resources (yield), , અને testing માટે — જે તેને વાસ્તવિક applications ને structure કરવા માટે એક બહુમુખી સાધન બનાવે છે.
def get_token(authorization: str = Header()):
return parse(authorization)
def get_current_user(token: str = Depends(get_token)): # depends on another dependency
return decode(token)
def get_admin(user: User = Depends(get_current_user)): # depends on that, in turn
if not user.is_admin: raise HTTPException(403)
return user
# FastAPI resolves the whole chain, caching shared dependencies within a request
Dependencies અન્ય dependencies પર આધાર રાખી શકે છે, جس FastAPI automatically resolve કરે છે (અને caches shared ones per request, તેથી get_token એક જ વાર run થાય છે ભલે કેટલાક dependencies દ્વારા ઉપયોગ થાય).
class RateLimiter:
def __init__(self, calls: int): # configure the dependency
self.calls = calls
def __call__(self, request: Request): # callable → acts as a dependency
check_rate_limit(request, self.calls)
@app.get("/items", dependencies=[Depends(RateLimiter(calls=100))]) # configured per route
def items(): ...
__call__ સાથે એક class એ એક configurable dependency છે — તમે તેને use time પર parameterize કરો છો (ઉદાહરણ તરીકે prote route દીઠ વિવિધ rate limits).
@app.get("/admin", dependencies=[Depends(verify_admin)]) # run for the effect (auth check)
def admin(): ... # don't need its return value
app = FastAPI(dependencies=[Depends(verify_api_key)]) # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)]) # to all routes in a router
App-wide અથવા per-router dependencies લાગુ કરો cross-cutting requirements (auth, rate limiting) માટે.
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
FastAPI નો dependency injection તેની સૌથી શક્તિશાળી વિશેષતાઓમાંથી એક છે, અને આ advanced patterns તે છે જે તમને વાસ્તવિક, જટિલ applications ને ભલીમણતાથી structure કરવા દે છે.
તેમને સમજવું મૂલ્યવાન senior-level જ્ઞાન છે: sub-dependencies reusable layers (token → user → admin) બનાવે છે જે automatic resolution અને per-request caching (અનાવશ્યક કામ ટાળે છે); parameterized/class-based dependencies configurable, reusable components બનાવે છે (rate limiters, permission checks વિવિધ settings સાથે per route); dependencies as side-effects requirements (auth) ને સ્વચ્છતાથી impose કરે છે function signatures ને cluttering કર્યા વિના; અને global/router-level dependencies cross-cutting concerns (authentication, rate limiting) ને routes ના પૂર્ણ groups પર એક જગ્યાએ લાગુ કરે છે. "):ંતુ રીતે, dependency overrides complex dependency graphs ને તુચ્છ testable બનાવે છે.
આ patterns ને નિપુણતા પ્રાપ્ત કરવી — dependencies ને compose કરવી, તેમને parameterize કરવી, તેમને globally અથવા per-router ને scope કરવી, અને tests માં તેમને override કરવી — એ છે જે non-trivial FastAPI applications માં clean, DRY, testable architecture સક્ષમ કરે છે, developers ને ભેદ આપે છે જેઓ framework ના DI system ને સંપૂર્ણપણે leverage કરી શકે છે તેઓ પાસેથી જેઓ ફક્ત basic Depends ઉપયોગ કરે છે.
તે well-structured, maintainable, large-scale FastAPI apps બનાવવા માટે એક મહત્વપૂર્ણ વિષય છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો