Para hacer eso, puedes crear un response como se describe en [Devolver un Response Directamente](response-directly.md){.internal-link target=_blank}.

Luego establece Cookies en ella, y luego devuélvela:

{* ../../docs_src/response_cookies/tutorial001.py hl[10:12] *}

/// tip | Consejo

`UploadFile` tiene los siguientes métodos `async`. Todos ellos llaman a los métodos correspondientes del archivo por debajo (usando el `SpooledTemporaryFile` interno).

* `write(data)`: Escribe `data` (`str` o `bytes`) en el archivo.

{* ../../docs_src/custom_response/tutorial009c.py hl[9:14,17] *}

이제 다음 대신:

```json
{"message": "Hello World"}
```

이 응답은 이렇게 반환됩니다:

```json
{
  "message": "Hello World"
}
```

물론 JSON 포맷팅보다 더 유용하게 활용할 방법을 찾을 수 있을 것입니다. 😉

## 기본 응답 클래스

**FastAPI** 클래스 객체 또는 `APIRouter`를 생성할 때 기본적으로 사용할 응답 클래스를 지정할 수 있습니다.

./mc ready minio1 --insecure
./mc ready minio2 --insecure

# Prepare data for tests
echo -n "Preparing test data ..."
mkdir -p /tmp/data
echo "Hello world" >/tmp/data/plainfile
echo "Hello from encrypted world" >/tmp/data/encrypted
touch /tmp/data/defpartsize
shred -s 500M /tmp/data/defpartsize
touch /tmp/data/mpartobj.txt
shred -s 500M /tmp/data/mpartobj.txt
echo "done"

### Stwórz

* Utwórz plik o nazwie `main.py` z:

```Python
from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}
```

<details markdown="1">

/**
 * Tests for {@link SerializableTester}.
 *
 * @author Nick Kralevich
 */
@NullUnmarked
public class SerializableTesterTest extends TestCase {
  public void testStringAssertions() {
    String original = "hello world";
    String copy = SerializableTester.reserializeAndAssert(original);
    assertEquals(original, copy);
    assertNotSame(original, copy);
  }

  public void testClassWhichDoesNotImplementEquals() {

import okio.GzipSource
import okio.buffer
import okio.use
import org.junit.jupiter.api.Test

class RequestTest {
  @Test
  fun constructor() {
    val url = "https://example.com/".toHttpUrl()
    val body = "hello".toRequestBody()
    val headers = headersOf("User-Agent", "RequestTest")
    val method = "PUT"
    val request =
      Request(
        url = url,
        headers = headers,
        method = method,

./mc replicate add sitea/bucket --remote-bucket siteb/bucket

# Run the test to make sure proxying of DEL marker doesn't happen
loop_count=0
while true; do
	if [ $loop_count -eq 1000 ]; then
		break
	fi
	echo "Hello World" | ./mc pipe sitea/bucket/obj$loop_count
	./mc rm sitea/bucket/obj$loop_count
	RESULT=$({ ./mc stat --no-list sitea/bucket/obj$loop_count; } 2>&1)
	if [[ ${RESULT} != *"Object does not exist"* ]]; then

    }

    @Test
    @DisplayName("Should encode and decode strings using byte operations")
    void testStringOperations() {
        // Given
        String testString = "Hello";
        byte[] buffer = new byte[testString.length()];

        // When - Manual string encoding using individual bytes
        byte[] strBytes = testString.getBytes();

        InvertibleCryptographer cryptographer = securityResourceProvider.providePrimaryInvertibleCryptographer();
        assertNotNull(cryptographer);

        String plainText = "Hello, World!";
        String encrypted = cryptographer.encrypt(plainText);
        assertNotNull(encrypted);
        assertFalse(plainText.equals(encrypted));

        String decrypted = cryptographer.decrypt(encrypted);