}

    @Override
    public void ensureBucketExists() {
        try {
            final Bucket existingBucket = storage.get(bucket);
            if (existingBucket == null) {
                storage.create(BucketInfo.newBuilder(bucket).build());
                logger.info("Created storage bucket: {}", bucket);
            }
        } catch (final Exception e) {

        assertTrue(dataStoreParams.containsKey("key2"));
        assertTrue(dataStoreParams.containsKey("key3"));
        assertTrue(dataStoreParams.containsKey("key4"));

        // Create a copy
        DataStoreParams copy = dataStoreParams.newInstance();

        // Modify original
        dataStoreParams.put("key5", "value5");

        // Verify copy is independent

    suite.addTest(testsForSetUpTearDown());
    return suite;
  }

  private abstract static class WrappedHashMapGenerator extends TestStringMapGenerator {
    @Override
    protected final Map<String, String> create(Entry<String, String>[] entries) {
      HashMap<String, String> map = new HashMap<>();
      for (Entry<String, String> entry : entries) {
        map.put(entry.getKey(), entry.getValue());
      }
      return wrap(map);

  /** Creates an empty {@code CompactLinkedHashMap} instance. */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> create() {
    return new CompactLinkedHashMap<>();
  }

  /**
   * Creates a {@code CompactLinkedHashMap} instance, with a high enough "initial capacity" that it

    return requireNonNull(values[cellRowIndices[index]][cellColumnIndices[index]]);
  }

  @Override
  @J2ktIncompatible
  @GwtIncompatible
    Object writeReplace() {
    return SerializedForm.create(this, cellRowIndices, cellColumnIndices);
  }

        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch doneLatch = new CountDownLatch(threadCount);
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        // Create test data
        byte[] testData = new byte[64];
        for (int i = 0; i < testData.length; i++) {
            testData[i] = (byte) i;
        }

        // Run concurrent updates

## Pydantics `BaseModel` importieren { #import-pydantics-basemodel }

Zuerst müssen Sie `BaseModel` von `pydantic` importieren:

{* ../../docs_src/body/tutorial001_py310.py hl[2] *}

## Ihr Datenmodell erstellen { #create-your-data-model }

Dann deklarieren Sie Ihr Datenmodell als eine Klasse, die von `BaseModel` erbt.

Verwenden Sie Standard-Python-Typen für alle Attribute:

{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}

When you install FastAPI, it comes with a production server, Uvicorn, and you can start it with the `fastapi run` command.

But you can also install an ASGI server manually.

Make sure you create a [virtual environment](../virtual-environments.md), activate it, and then you can install the server application.

For example, to install Uvicorn:

<div class="termy">

```console
$ pip install "uvicorn[standard]"

#### Pydantic's `.model_dump()` { #pydantics-model-dump }

`user_in` is a Pydantic model of class `UserIn`.

Pydantic models have a `.model_dump()` method that returns a `dict` with the model's data.

So, if we create a Pydantic object `user_in` like:

```Python
user_in = UserIn(username="john", password="secret", email="******@****.***")
```

and then we call:

```Python
user_dict = user_in.model_dump()
```

- `description`：一个 `str`，该标签的简短描述。可以使用 Markdown，并会显示在文档 UI 中。
- `externalDocs`：一个 `dict`，描述外部文档，包含：
    - `description`：一个 `str`，该外部文档的简短描述。
    - `url`（必填）：一个 `str`，该外部文档的 URL。

### 创建标签元数据 { #create-metadata-for-tags }

让我们在带有标签的示例中为 `users` 和 `items` 试一下。

创建标签元数据并把它传递给 `openapi_tags` 参数：

{* ../../docs_src/metadata/tutorial004_py310.py hl[3:16,18] *}