{!> ../../../docs_src/header_params/tutorial003.py!}
    ```

Wenn Sie mit einer *Pfadoperation* kommunizieren, die zwei HTTP-Header sendet, wie:

```
X-Token: foo
X-Token: bar
```

Dann wäre die Response:

```JSON
{
    "X-Token values": [
        "bar",
        "foo"
    ]
}
```

## Zusammenfassung

* `summary`: A short summary of the API.
* `description`: The description of your API, this can include markdown and will be shown in the docs.
* `routes`: A list of routes, these are each of the registered *path operations*. They are taken from `app.routes`.

!!! info
    The parameter `summary` is available in OpenAPI 3.1.0 and above, supported by FastAPI 0.99.0 and above.

## Overriding the defaults

internal class KtFe10SymbolProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtSymbolProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol
        get() = KtFe10PackageSymbol(FqName.ROOT, analysisContext)

    override fun getFileSymbol(psi: KtFile): KtFileSymbol {

      call.execute()
    }
    val elapsedNanos = System.nanoTime() - startNanos
    org.junit.jupiter.api.Assertions.assertTrue(
      elapsedNanos < TimeUnit.SECONDS.toNanos(5),
      "Timeout should have taken ~100ms but was " + elapsedNanos / 1e6 + " ms",
    )
  }

  @Test
  fun chainWithReadTimeout() {
    val interceptor1 =
      Interceptor { chainA: Interceptor.Chain ->

internal class KtFe10SymbolInfoProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtSymbolInfoProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    override fun getDeprecation(symbol: KtSymbol): DeprecationInfo? {
        val descriptor = getSymbolDescriptor(symbol) ?: return null
        ForceResolveUtil.forceResolveAllContents(descriptor)

<img src="/img/tutorial/security/image11.png">

## JWT token with scopes

Now, modify the token *path operation* to return the scopes requested.

We are still using the same `OAuth2PasswordRequestForm`. It includes a property `scopes` with a `list` of `str`, with each scope it received in the request.

And we return the scopes as part of the JWT token.

!!! danger

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion {
            descriptor?.let { KtFe10AnnotationsList.create(it.annotations, analysisContext) } ?: KtEmptyAnnotationsList(token)
        }

    @OptIn(KtAnalysisApiInternals::class)
    override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> = withValidityAssertion {

      return@schedule -1L
    }

    queue.idleLatch().await(500, TimeUnit.MILLISECONDS)

    assertThat(log.take()).isEqualTo("failing task running")
    assertThat(log.take()).isEqualTo("uncaught exception: java.lang.RuntimeException: boom!")
    assertThat(log.take()).isEqualTo("normal task running")
    assertThat(log).isEmpty()
  }

  @Test fun idleLatchAfterShutdown() {
    queue.schedule("task") {

# Dependencies - `Depends()` and `Security()`

## `Depends()`

Dependencies are handled mainly with the special function `Depends()` that takes a callable.

Here is the reference for it and its parameters.

You can import it directly from `fastapi`:

```python
from fastapi import Depends
```

::: fastapi.Depends

## `Security()`

import org.jetbrains.kotlin.psi.KtDeclaration
import org.jetbrains.kotlin.psi.KtFile

internal class KtFirOriginalPsiProvider(
    override val analysisSession: KtFirAnalysisSession,
    override val token: KtLifetimeToken,
) : KtOriginalPsiProvider(), KtFirAnalysisSessionComponent {
    override fun getOriginalDeclaration(declaration: KtDeclaration): KtDeclaration? = declaration.originalDeclaration