assert response.status_code == 200, response.text
    assert response.json() == snapshot(
        {
            "openapi": "3.1.0",
            "info": {"title": "FastAPI", "version": "0.1.0"},
            "paths": {
                "/": {
                    "get": {
                        "summary": "Route With Extra Query Parameters",
                        "operationId": "route_with_extra_query_parameters__get",

    assert response.status_code == 200, response.text
    assert response.json() == snapshot(
        {
            "openapi": "3.1.0",
            "info": {"title": "FastAPI", "version": "0.1.0"},
            "paths": {
                "/users/me": {
                    "get": {
                        "responses": {
                            "200": {
                                "description": "Successful Response",

Entonces podemos usar la dependencia con:

{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[23] *}

/// info | Información

Fíjate que solo estamos declarando una dependencia en la *path operation function*, `query_or_cookie_extractor`.

Pero **FastAPI** sabrá que tiene que resolver `query_extractor` primero, para pasar los resultados de eso a `query_or_cookie_extractor` al llamarlo.

///

```mermaid

Si tienes bastante conocimiento técnico (coroutines, hilos, bloqueo, etc.) y tienes curiosidad sobre cómo FastAPI maneja `async def` vs `def` normal, adelante.

///

### Funciones de *path operation* { #path-operation-functions }

Cuando declaras una *path operation function* con `def` normal en lugar de `async def`, se ejecuta en un threadpool externo que luego es esperado, en lugar de ser llamado directamente (ya que bloquearía el servidor).

  override fun toString() = "input=$input output=$output"

  companion object {
    fun load(): List<WebPlatformToAsciiData> {
      val path = okHttpRoot / "okhttp/src/jvmTest/resources/web-platform-test-toascii.json"
      return SYSTEM_FILE_SYSTEM.read(path) {
        Json.decodeFromString<List<WebPlatformToAsciiData>>(readUtf8())
      }
    }
  }

```python
from backend.main import app
```

### `fastapi dev` with path { #fastapi-dev-with-path }

You can also pass the file path to the `fastapi dev` command, and it will guess the FastAPI app object to use:

```console
$ fastapi dev main.py
```

But you would have to remember to pass the correct path every time you call the `fastapi` command.

    }

    @Test
    @DisplayName("sendrecv SMB2 path issues IOCTL and returns response length")
    void testSendRecvSmb2() throws IOException, CIFSException {
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

        // ensureOpen path
        when(tree.isSMB2()).thenReturn(true);

def test_request_with_depends_annotated():
    """Request type hint should work in dependency chain."""
    app = FastAPI()

    def extract_request_info(request: Request) -> dict:
        return {
            "path": request.url.path,
            "user_agent": request.headers.get("user-agent", "unknown"),
        }

    @app.get("/")
    def endpoint(
        info: Annotated[dict, Depends(extract_request_info)],
    ):

            if (isDeployedBranch()) {
              withEnv(["JAVA_HOME=${tool "jdk_17_latest"}",
                       "PATH+MAVEN=${ tool "jdk_17_latest" }/bin:${tool "maven_3_latest"}/bin",
                       "MAVEN_OPTS=-Xms4G -Xmx4G -Djava.awt.headless=true"]) {
                sh "./mvnw clean deploy -DdeployAtEnd=true -B -V"
              }

///

Necesitas importar `WSGIMiddleware` de `a2wsgi`.

Luego envuelve la aplicación WSGI (p. ej., Flask) con el middleware.

Y luego móntala bajo un path.

{* ../../docs_src/wsgi/tutorial001_py310.py hl[1,3,23] *}

/// note | Nota

Anteriormente, se recomendaba usar `WSGIMiddleware` de `fastapi.middleware.wsgi`, pero ahora está deprecado.