## `Security` in Dekorator-`dependencies` { #security-in-decorator-dependencies }

  <artifactId>maven-api-xml</artifactId>
  <name>Maven 4 API :: XML</name>
  <description>Maven 4 API - Immutable XML.</description>

  <dependencies>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-api-annotations</artifactId>
    </dependency>
  </dependencies>

app = FastAPI()


async def response_status_setter(response: Response):
    response.status_code = 201


async def parent_dep(result=Depends(response_status_setter)):
    return result


@app.get("/", dependencies=[Depends(parent_dep)])
async def get_main():
    return {"msg": "Hello World"}


client = TestClient(app)


def test_dependency_set_status_code():
    response = client.get("/")

}

project.applyOsgi(
  "Export-Package: okhttp3.java.net.cookiejar",
  "Bundle-SymbolicName: com.squareup.okhttp3.java.net.cookiejar"
)

project.applyJavaModules("okhttp3.java.net.cookiejar")

dependencies {
  "friendsApi"(projects.okhttp)
  compileOnly(libs.animalsniffer.annotations)
}

mavenPublishing {
  configure(KotlinJvm(javadocJar = JavadocJar.Empty()))

async def verify_key(x_key: str = Header()):
    if x_key != "fake-super-secret-key":
        raise HTTPException(status_code=400, detail="X-Key header invalid")
    return x_key


@app.get("/items/", dependencies=[Depends(verify_token), Depends(verify_key)])
async def read_items():

            if (scopeToResolve != null && !scopeToResolve.isEmpty()) {
                scopesToResolve.add(scopeToResolve);
            }
        }

        logger.debug("Dependencies (collect): " + scopesToCollect);
        logger.debug("Dependencies (resolve): " + scopesToResolve);
    }

# `HTTPConnection` class

When you want to define dependencies that should be compatible with both HTTP and WebSockets, you can define a parameter that takes an `HTTPConnection` instead of a `Request` or a `WebSocket`.

You can import it from `fastapi.requests`:

```python
from fastapi.requests import HTTPConnection
```

  id("binary-compatibility-validator")
}

project.applyOsgi(
  "Export-Package: okhttp3.logging",
  "Bundle-SymbolicName: com.squareup.okhttp3.logging"
)

project.applyJavaModules("okhttp3.logging")

dependencies {
  "friendsApi"(projects.okhttp)

  testImplementation(libs.junit)
  testImplementation(projects.mockwebserver3)
  testImplementation(projects.mockwebserver3Junit5)
  testImplementation(projects.okhttpTestingSupport)

from contextlib import AsyncExitStack

from starlette.types import ASGIApp, Receive, Scope, Send


# Used mainly to close files after the request is done, dependencies are closed
# in their own AsyncExitStack
class AsyncExitStackMiddleware:
    def __init__(
        self, app: ASGIApp, context_name: str = "fastapi_middleware_astack"
    ) -> None:
        self.app = app
        self.context_name = context_name

        super(
                "Plugin " + plugin.getId() + " or one of its dependencies could not be resolved: " + cause.getMessage(),
                cause);
        this.plugin = plugin;
    }

    public PluginResolutionException(Plugin plugin, List<Exception> exceptions, Throwable cause) {
        super(
                "Plugin " + plugin.getId() + " or one of its dependencies could not be resolved:"