builder.addSort("_score", SortOrder.DESC);

        // set filter query.
        final List<QueryBuilder> filterList = new ArrayList<>(10);
        if (!tags.isEmpty()) {
            filterList.add(buildFilterQuery(FieldNames.TAGS, tags));
        }

        roles.add(SuggestConstants.DEFAULT_ROLE);
        if (!roles.isEmpty()) {
            filterList.add(buildFilterQuery(FieldNames.ROLES, roles));

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None
    tags: set[str] = set()


@app.post("/items/", response_model=Item, summary="Create an item")
async def create_item(item: Item):
    """
    Create an item with all the information:

    - **name**: each item must have a name

<img src="/img/tutorial/generate-clients/image05.png">

## FastAPI App with Tags

In many cases your FastAPI app will be bigger, and you will probably use tags to separate different groups of *path operations*.

For example, you could have a section for **items** and another section for **users**, and they could be separated by tags:

//// tab | Python 3.9+

```Python hl_lines="21  26  34"

        projectId = "Check",
        branch = VersionedSettingsBranch.fromDslContext(),
        buildScanTags = listOf("Check"),
        subprojects = subprojectProvider
    )

    @Test
    fun `test stage tags`() {
        assertEquals(
            "-DbuildScan.PartOf=QuickFeedbackLinuxOnly,QuickFeedback,PullRequestFeedback,ReadyforNightly,ReadyforRelease",
            model.stages[0].getBuildScanCustomValueParam()
        )

    @Override
    protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
      Map<AnEnum, String> map = Maps.newHashMap();
      for (Entry<AnEnum, String> entry : entries) {
        checkNotNull(entry);
        map.put(entry.getKey(), entry.getValue());
      }
      return Maps.immutableEnumMap(map);
    }
  }

  public static class ImmutableMapCopyOfEnumMapGenerator extends TestEnumMapGenerator {

## Dokümantasyon Etiketleri - OpenAPI

*Yol operasyonlarınıza* etiketler ekleyerek dokümantasyon arayüzünde gruplar halinde görünmesini sağlamak için, [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank} sayfasını okuyun.

## Dokümantasyon Özeti ve Açıklaması - OpenAPI

                                 ForwardOperation*);

// Make the call to `Tape::RecordOperation`.
absl::Status Execute(AbstractOperation*, AbstractContext*,
                     absl::Span<AbstractTensorHandle*> retvals,
                     int* num_retvals, ForwardOperation*, Tape*,
                     const GradientRegistry&);

}  // namespace internal
}  // namespace gradients

  }

  public final boolean containsKey(@Nullable Object key) {
    return Maps.safeContainsKey(delegate, key);
  }

  public final boolean containsValue(@Nullable Object value) {
    return delegate.containsValue(value);
  }

  public @Nullable V get(@Nullable Object key) {
    return (key == null) ? null : Maps.safeGet(delegate, key);
  }

  @Override
  ImmutableSet<Entry<K, V>> createEntrySet() {

    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

  public void testBuilderWithExpectedKeysPositive() {
    ImmutableSetMultimap.Builder<String, String> builder =
        ImmutableSetMultimap.builderWithExpectedKeys(1);
    builder.put("key", "value");
    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

    description: Union[str, None] = None
    price: Union[float, None] = None
    tax: float = 10.5
    tags: list[str] = []


items = {
    "foo": {"name": "Foo", "price": 50.2},
    "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2},
    "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []},
}


@app.get("/items/{item_id}", response_model=Item)