}

    public void test_parse() {
        PrunedTag[] tags = PrunedTag.parse("");
        assertEquals(0, tags.length);

        tags = PrunedTag.parse("a");
        assertEquals(1, tags.length);
        assertEquals("PrunedTag [tag=a, id=null, css=null, attrName=null, attrValue=null]", tags[0].toString());

        tags = PrunedTag.parse("a#test");
        assertEquals(1, tags.length);

	defer r.Unlock()
	// Search of tag key already exists in tags
	var updated bool
	for _, tag := range r.tags {
		if tag.Key == key {
			tag.Val = val
			updated = true
			break
		}
	}
	if !updated {
		// Append to the end of tags list
		r.tags = append(r.tags, KeyVal{key, val})
	}
	return r
}

// GetTags - returns the user defined tags
func (r *ReqInfo) GetTags() []KeyVal {
	if r == nil {

                                    "required": ["name", "tags"],
                                    "type": "object",
                                    "properties": {
                                        "name": {"title": "Name", "type": "string"},
                                        "tags": {
                                            "title": "Tags",
                                            "type": "array",

from enum import Enum

from fastapi import FastAPI

app = FastAPI()


class Tags(Enum):
    items = "items"
    users = "users"


@app.get("/items/", tags=[Tags.items])
async def get_items():
    return ["Portal gun", "Plumbus"]


@app.get("/users/", tags=[Tags.users])
async def read_users():

)

// And - a tag to combine a prefix and multiple tags for replication configuration rule.
type And struct {
	XMLName xml.Name `xml:"And" json:"And"`
	Prefix  string   `xml:"Prefix,omitempty" json:"Prefix,omitempty"`
	Tags    []Tag    `xml:"Tag,omitempty" json:"Tag,omitempty"`
}

var errDuplicateTagKey = Errorf("Duplicate Tag Keys are not allowed")

// isEmpty returns true if Tags field is null
func (a And) isEmpty() bool {

/// tip

You don't have to add metadata for all the tags that you use.

///

### Use your tags

Use the `tags` parameter with your *path operations* (and `APIRouter`s) to assign them to different tags:

```Python hl_lines="21  26"
{!../../docs_src/metadata/tutorial004.py!}
```

/// info

Read more about tags in [Path Operation Configuration](path-operation-configuration.md#tags){.internal-link target=_blank}.

///

		ilmNewerNoncurrentVersions = "ilm-newer-noncurrent-versions"
		ilmNoncurrentDays          = "ilm-noncurrent-days"
	)
	tags := make(map[string]string, 5)
	if src > lcEventSrc_None {
		tags[ilmSrc] = src.String()
	}
	tags[ilmAction] = event.Action.String()
	tags[ilmRuleID] = event.RuleID

	if !event.Due.IsZero() {
		tags[ilmDue] = event.Due.Format(iso8601Format)
	}

	// rule with Transition/NoncurrentVersionTransition in effect

<%@taglib prefix="c" uri="jakarta.tags.core"%><%--
 --%><%@taglib prefix="fmt" uri="jakarta.tags.fmt"%><%--
 --%><%@taglib prefix="fn" uri="jakarta.tags.functions" %><%--
 --%><%@taglib prefix="la" uri="http://lastaflute.org/latags" %><%--
 --%><%@taglib prefix="f" uri="http://lastaflute.org/functions" %><%--
 --%><%@taglib prefix="fe" uri="fess.tags.functions" %><%--

    price: float
    tax: Union[float, None] = None
    tags: set[str] = set()


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


@app.get("/items/", tags=["items"])
async def read_items():
    return [{"name": "Foo", "price": 42}]


@app.get("/users/", tags=["users"])
async def read_users():

	x := make(map[string]struct{}, len(a.Tags))

	for _, t := range a.Tags {
		if _, has := x[t.Key]; has {
			return true
		}
		x[t.Key] = struct{}{}
	}

	return false
}

// BySize returns true when sz satisfies a
// ObjectSizeLessThan/ObjectSizeGreaterthan or a logical AND of these predicates
// Note: And combines size and other predicates like Tags, Prefix, etc. This