## Usage

    Create an instance object and use that object as the dependency in `Depends()`.

    The dependency result will be a string containing the key value.

    ## Example

    ```python
    from fastapi import Depends, FastAPI
    from fastapi.security import APIKeyQuery

    app = FastAPI()

    query_scheme = APIKeyQuery(name="api_key")


    @app.get("/items/")

        // Test characters that need special encoding
        String input1 = "http://example.com/文档"; // Unicode characters
        String result1 = crawlingInfoHelper.generateId(input1);
        assertNotNull(result1);
        assertEquals(128, result1.length());

        String input2 = "http://example.com/path with spaces";
        String result2 = crawlingInfoHelper.generateId(input2);

![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)

### 대안 API 문서 { #alternative-api-docs }

그리고 이제 [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc)로 가봅시다.

다른 자동 문서를 볼 수 있습니다([ReDoc](https://github.com/Rebilly/ReDoc) 제공):

![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

## 예제 업그레이드 { #example-upgrade }

이제 `PUT` 요청에서 본문을 받기 위해 `main.py` 파일을 수정해봅시다.

    }

    @Test
    public void test_render_link_http() {
        String result = markdownRenderer.render("[Link](http://example.com)");
        assertTrue(result.contains("<a"));
        assertTrue(result.contains("href=\"http://example.com\""));
        assertTrue(result.contains("Link"));
        assertTrue(result.contains("rel=\"nofollow\""));
    }

    @Test

As all these methods are `async` methods, you need to "await" them.

For example, inside of an `async` *path operation function* you can get the contents with:

```Python
contents = await myfile.read()
```

If you are inside of a normal `def` *path operation function*, you can access the `UploadFile.file` directly, for example:

```Python
contents = myfile.file.read()
```

/// note | `async` Technical Details

    throw new NullPointerException("Both parameters are null");
  }

  /**
   * Creates an instance of {@link ToStringHelper}.
   *
   * <p>This is helpful for implementing {@link Object#toString()}. Specification by example:
   *
   * {@snippet :
   * // Returns "ClassName{}"
   * MoreObjects.toStringHelper(this)
   *     .toString();
   *
   * // Returns "ClassName{x=1}"
   * MoreObjects.toStringHelper(this)

/// note

Notice that, in this case, the `item` that would be taken from the body is optional. As it has a `None` default value.

///

## Multiple body parameters { #multiple-body-parameters }

In the previous example, the *path operations* would expect a JSON body with the attributes of an `Item`, like:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2
}
```

that can send requests to a Gradle daemon.
Each daemon runs one request at a time. Generally speaking, the daemons only act in response to a request from a client and do not take any action on their own.
There are some background actions that the daemon takes, for example monitoring system memory, watching for file changes or cleaning up caches.

 * if there are any Rest YAML tests present in source, or copied from {@link CopyRestTestsTask} output. X-pack specs must be explicitly
 * declared to be copied.
 * <br>
 * <i>For example:</i>
 * <pre>
 * restResources {
 *   restApi {
 *     includeXpack 'enrich'
 *   }
 * }
 * </pre>

@app.put("/items/{item_id}")
async def update_item(
    *,
    item_id: int,
    item: Item = Body(
        openapi_examples={
            "normal": {
                "summary": "A normal example",
                "description": "A **normal** item works correctly.",
                "value": {
                    "name": "Foo",
                    "description": "A very nice Item",
                    "price": 35.4,