### Özel `tags`, `responses` ve `dependencies` Ekleyin { #add-some-custom-tags-responses-and-dependencies }

`/items` prefix’ini ya da `tags=["items"]` değerini her *path operation*’a tek tek eklemiyoruz; çünkü bunları `APIRouter`’a ekledik.

Ama yine de belirli bir *path operation*’a uygulanacak _ek_ `tags` tanımlayabilir, ayrıca o *path operation*’a özel `responses` ekleyebiliriz:

		}

		if len(r.Flags.Filter.Tags) > 0 {
			// Only parse object tags if tags filter is specified.
			tagMap := map[string]string{}
			tagStr := info.Metadata[xhttp.AmzObjectTagging]
			if len(tagStr) != 0 {
				t, err := tags.ParseObjectTags(tagStr)
				if err != nil {
					return false
				}
				tagMap = t.ToMap()
			}

			for _, kv := range r.Flags.Filter.Tags {
				for t, v := range tagMap {

	}

	// Set tag count if object has tags
	if len(objInfo.UserTags) > 0 {
		tags, _ := tags.ParseObjectTags(objInfo.UserTags)
		if tags != nil && tags.Count() > 0 {
			w.Header()[xhttp.AmzTagCount] = []string{strconv.Itoa(tags.Count())}
			if opts.Tagging {
				// This is MinIO only extension to return back tags along with the count.

     * @param fields The fields
     * @param tags The tags
     * @param roles The roles
     * @param num The number
     * @param langs The languages
     * @param badWords The bad words array
     * @return The SuggestIndexResponse
     */
    public SuggestIndexResponse indexFromSearchWord(final String index, final String searchWord, final String[] fields, final String[] tags,

		return false
	}

	if len(ef.Tags) > 0 && !obj.DeleteMarker {
		// Only parse object tags if tags filter is specified.
		var tagMap map[string]string
		if len(obj.UserTags) != 0 {
			t, err := tags.ParseObjectTags(obj.UserTags)
			if err != nil {
				return false
			}
			tagMap = t.ToMap()
		}

		for _, kv := range ef.Tags {
			// Object (version) must match all tags specified in
			// the filter

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags con Enums { #tags-with-enums }

Si tienes una gran aplicación, podrías terminar acumulando **varias tags**, y querrías asegurarte de que siempre uses la **misma tag** para *path operations* relacionadas.

En estos casos, podría tener sentido almacenar las tags en un `Enum`.

**FastAPI** soporta eso de la misma manera que con strings normales:

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags com Enums { #tags-with-enums }

Se você tem uma grande aplicação, você pode acabar acumulando **várias tags**, e você gostaria de ter certeza de que você sempre usa a ** mesma tag** para *operações de rota* relacionadas.

Nestes casos, pode fazer sentido armazenar as tags em um `Enum`.

**FastAPI** suporta isso da mesma maneira que com strings simples:

  # "Tag: <new whl tag>"
  sed -i "s/^Tag:.*/Tag: ${whl_tag}/g" "${pkg_name}"/"${pkg_name}".dist-info/WHEEL

  # Repack the wheel. When repacking, the wheel would be automatically tagged
  # with the new tag we provided in ${whl_tag}. Repacking also regnerates the
  # RECORD file which contains hashes of all included files.
  python3 -m wheel pack "${pkg_name}"
done

  }

  override fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags.get()[type])

  override fun <T> tag(type: Class<out T>): T? = tag(type.kotlin)

  override fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T = tags.computeIfAbsent(type, computeIfAbsent)

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,

name: Create Release

on:
  push:
    tags:
      - 'v*.*.*'

permissions:
  contents: write
  pull-requests: read

jobs:
  create_release:
    name: Create Release
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Generate Release Notes and Publish
        id: generate_release_notes
        uses: release-drafter/release-drafter@v6