"description": "Successful Response",
                            "content": {"application/json": {"schema": {}}},
                        }
                    },
                    "tags": ["items"],
                    "summary": "Read Items",
                    "operationId": "read_items_items__get",
                }
            },
            "/users/": {
                "get": {

✋️ 🔜 👆 💭 ❔ ⚫️ 👷, 👆 💪 ⚙️ ⚖ 🗄 👆 👍 📱 🙅‍♂ 🤔 ❔ 🏗 👫. 👶

### 🚮 🛃 `tags`, `responses`, & `dependencies`

👥 🚫 ❎ 🔡 `/items` 🚫 `tags=["items"]` 🔠 *➡ 🛠️* ↩️ 👥 🚮 👫 `APIRouter`.

✋️ 👥 💪 🚮 _🌅_ `tags` 👈 🔜 ✔ 🎯 *➡ 🛠️*, & ➕ `responses` 🎯 👈 *➡ 🛠️*:

```Python hl_lines="30-31" title="app/routers/items.py"

	API := "SYSTEM"
	switch {
	case req.API != "":
		API = req.API
	case subsystem != "":
		API += "." + subsystem
	}

	// Copy tags. We hold read lock already.
	tags := make(map[string]interface{}, len(req.tags))
	for _, entry := range req.tags {
		tags[entry.Key] = entry.Val
	}

	// Get the cause for the Error
	deploymentID := req.DeploymentID
	if req.DeploymentID == "" {

                        "tags": {
                            "items": {"type": "string"},
                            "type": "array",
                            "title": "Tags",
                            "default": [],
                        },
                    },
                    "type": "object",
                    "required": ["subname", "sub_description", "tags"],
                    "title": "SubItem",

from fastapi import APIRouter

router = APIRouter()


@router.get("/users/", tags=["users"])
async def read_users():
    return [{"username": "Rick"}, {"username": "Morty"}]


@router.get("/users/me", tags=["users"])
async def read_user_me():
    return {"username": "fakecurrentuser"}


@router.get("/users/{username}", tags=["users"])
async def read_user(username: str):

    ],
)

tf_cuda_cc_test(
    name = "gradients_test",
    size = "small",
    srcs = [
        "gradients_test.cc",
    ],
    args = ["--heap_check="],
    tags = tf_cuda_tests_tags() + ["nomac"],
    deps = [
        ":abstract_context",
        ":abstract_tensor_handle",
        ":c_api_experimental",
        ":c_api_test_util",
        ":c_api_unified_internal",

			ReplicationRequest: true, // always set this to distinguish between `mc mirror` replication and serverside
		},
	}
	if objInfo.UserTags != "" {
		tag, _ := tags.ParseObjectTags(objInfo.UserTags)
		if tag != nil {
			putOpts.UserTags = tag.ToMap()
			// set tag timestamp in opts
			tagTimestamp := objInfo.ModTime
			if tagTmstampStr, ok := objInfo.UserDefined[ReservedMetadataPrefixLower+TaggingTimestamp]; ok {

```

////

## Set-Typen

Aber dann denken wir darüber nach und stellen fest, dass sich die Tags nicht wiederholen sollen, es sollen eindeutige Strings sein.

Python hat einen Datentyp speziell für Mengen eindeutiger Dinge: das <abbr title="Menge">`set`</abbr>.

Deklarieren wir also `tags` als Set von Strings.

//// tab | Python 3.10+

```Python hl_lines="12"

        private final String tag;

        private final int hash;

        GavCacheKey(String groupId, String artifactId, String version, String tag) {
            this(gav(groupId, artifactId, version), tag);
        }

        GavCacheKey(String gav, String tag) {
            this.gav = gav;
            this.tag = tag;
            this.hash = Objects.hash(gav, tag);
        }

@app.post("/items/", response_model=ResponseMessage, tags=["items"])
async def create_item(item: Item):
    return {"message": "Item received"}


@app.get("/items/", response_model=list[Item], tags=["items"])
async def get_items():
    return [
        {"name": "Plumbus", "price": 3},
        {"name": "Portal Gun", "price": 9001},
    ]


@app.post("/users/", response_model=ResponseMessage, tags=["users"])
async def create_user(user: User):