როგორ მუშაობს დამოკიდებულების შეყვანა (Depends)?

Question

Accepted Answer

FastAPI-ის **დამოკიდებულების შეყვანის** სისტემა საშუალებას გაძლევთ დეკლარირებული გაიყიდოთ საკუთარი დამოკიდებულებები (ფუნქციები/კლასები), რომელსაც FastAPI იწვევს და **შეყავს** თქვენს ბილიკის ოპერაციებში `Depends()`-ის მეშვეობით. იგი გამოიყენება წაბილი ლოგიკისთვის, როგორიცაა მონაცემთა ბაზის სესიები, ავტორიზაცია და საერთო პარამეტრები — კოდი რჩება DRY-ი და ტესტირებადი.

## ძირითადი დამოკიდებულება

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

`params = Depends(pagination)`-ის დეკლარირება ეუბნება FastAPI-ს, რომ იწოდოს `pagination` (იმის პარამეტრებითურთ მოითხოვოს) და შედეგი გადააგო თქვენს ფუნქციაში. დამოკიდებულება არის გამოყენებული მრავალი საბოლოო წერტილით.

## დამოკიდებულებები სიმდიდრის მოშორებით (yield) — მაგალითად: მონაცემთა ბაზის სესიები

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

`yield` დამოკიდებულება საჭირო რესურსებს ქმნის და აკეთებს გაწმენდას მოთხოვნის შემდეგ — ეს არის სტანდარტული ნიმუში მონაცემთა ბაზის სესიებისთვის (გახსენი ადრე, დახურე შემდეგ, ავტომატურად).

## დამოკიდებულებები შეიძლება დამოკიდებელი იყოს სხვა დამოკიდებულებებზე

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

დამოკიდებულებები ქმნიან ხეს — FastAPI აგებს მთელ ჯაჭვს. ასე გაკეთებულია ავტორიზაცია (დამოკიდებულება `get_current_user`).

## კლასის დამოკიდებულებები და გამოყენება

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## რატომ მნიშვნელოვანი

დამოკიდებულების შეყვანა არის FastAPI-ის ერთ-ერთი ყველაზე მძლავრი და მნიშვნელოვანი ფუნქცია — ეს არის გზა, რომლითაც თქვენ გაზიარებული და უხელმძღვანელი ლოგიკა სფეროების გამოყენებით (მონაცემთა ბაზის სესიები, ავტორიზაცია, ხშირი მოთხოვნის პარამეტრები, დაკავშირება) დუბლირების გარეშე.

ამის გაგება ძირითადი, რადგან ეს არის სხვადსხვა კერძო ნიმუშის საფუძველი: **`yield` დამოკიდებულება** არის სტანდარტული გზა მონაცემთა ბაზის სესიების მართვისთვის (გარანტირებული გაწმენდით თითოეულ მოთხოვნის შემდეგ), და **`get_current_user` დამოკიდებულება** არის იდიომატური საშუალება ავტორიზაციის განხორციელებისთვის.

DI ასევე კოდს აკეთებს ძალიან **ტესტირებადს** — თქვენ შეგიძლიათ დამოკიდებულებების ჩანაცვლება მოკებით ტესტებში.

სისტემის კეთილშობილება (დამოკიდებულებები აგებენ საკუთარი პარამეტრებს მოთხოვნიდან, შეიძლება დამოკიდებელი იყოს სხვა დამოკიდებულებებზე და შენ ხეს, და ინტეგრირებული დოკუმენტაციასთან) კეთილშობილი ხელსაწყოა რეალური აპლიკაციების სტრუქტურირების საფუძველი, ამიტომ `Depends`-ის ჯერ-ჯერობით აღქმა არის გასაღები კარგი, შენარჩუნებული, ტესტირებადი FastAPI აპლიკაციების აგებისთვის.