რა მოწინავე დამოკიდებულების შაბლონებს supporting FastAPI?

Question

Accepted Answer

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

## ქვე-დამოკიდებულებები (დამოკიდებულების ხეები)

```python
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
```

დამოკიდებულებები შეიძლება დამოკიდებული იყვნენ სხვა დამოკიდებულებებზე, რაც ხეს ქმნის, რომელსაც FastAPI ავტომატურად აგებს (და **კეშირებს** საერთო ჯამებს თითოეული მოთხოვნის თითქმის, ასე რომ `get_token` ერთხელ გაუშვება მაშინაც კი, თუ რამდენიმე დამოკიდებულება იყენებს მას).

## პარამეტრიზებული (კლასზე დაფუძნებული) დამოკიდებულებები

```python
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__` მეთოდით არის **კონფიგურირებადი** დამოკიდებულება — თქვენ პარამეტრიზებთ მას გამოყენების დროს (მაგ. სხვადსხვა rate limits თითოეული route-ისთვის).

## დამოკიდებულებები როგორც გვერდითი ეფექტები (დაბრუნება არ არის საჭირო)

```python
@app.get("/admin", dependencies=[Depends(verify_admin)])   # run for the effect (auth check)
def admin(): ...                                            # don't need its return value
```

## გლობალური და router-ის დონის დამოკიდებულებები

```python
app = FastAPI(dependencies=[Depends(verify_api_key)])      # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)])  # to all routes in a router
```

გამოიყენეთ დამოკიდებულებები აპ-ის მასშტაბით ან თითოეული router-ის განვრცელი მოთხოვნების (auth, rate limiting) გამოსახატავად.

## გადაფარვა ტესტირებისთვის

```python
app.dependency_overrides[get_db] = get_test_db    # swap any dependency in tests
```

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

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

მათი გაგება ფასეული senior-level ცოდნაა: **ქვე-დამოკიდებულებები** აშენებს მిმოქცევადი ფენებს (token → user → admin) ავტომატური რეზოლუციით და თითოეული მოთხოვნის კეშირებით (რედუნდანტული სამუშაოს თავიდან აცილებით); **პარამეტრიზებული/კლასზე დაფუძნებული დამოკიდებულებები** იქმნება კონფიგურირებადი, მიმოქცევადი კომპონენტები (rate limiters, permission checks სხვადსხვა პარამეტრებით თითოეული route-ის); **დამოკიდებულებები როგორც გვერდითი ეფექტები**깔끔하게აღვრმევს მოთხოვნებს (auth) ფუნქციის ხელმოწერის გაკლებული; და **გლობალური/router-დონის დამოკიდებულებები** გამოიყენებენ განვრცელი შემოწმებები (authentication, rate limiting) route-ების მთელი ჯგუფებისთვის ერთ ადგილას.

მნიშვნელოვანია, **დამოკიდებულების გადაფარვა** აქცევს რთული დამოკიდებულების გრაფიკებს აბსოლუტურად მარტივი ტესტირებისთვის.

ამ შაბლონების დაუფლება — დამოკიდებულების კომპოზიცია, მათი პარამეტრიზება, მათი scoping გლობალურად ან თითოეული router-ის, და მათი გადაფარვა ტესტებში — არის ის, რაც აძლევს სუფთა, DRY, ტესტირებულ არქიტექტურას არა-ტრივიალური FastAPI აპლიკაციებში, რაც განასხვავებს რ developers, ვინც კარგად იყენებენ ჩარჩოს DI სისტემას, მათ, ვინც მხოლოდ უბრალო `Depends` იყენებენ.

ეს მნიშვნელოვანი თემაა კარგად-სტრუქტურირებული, მრავალფეროვანი, დიდი-მასშტაბის FastAPI აპლიკაციების აგების დროს.