items = {"foo": {"name": "Fighters", "size": 6}, "bar": {"name": "Tenders", "size": 3}}


@app.put("/items/{item_id}")
async def upsert_item(
    item_id: str,
    name: str | None = Body(default=None),
    size: int | None = Body(default=None),
):
    if item_id in items:
        item = items[item_id]
        item["name"] = name
        item["size"] = size
        return item
    else:

	rv=$?

	pkill minio
	sleep 3

	if [ "$rv" -ne 0 ]; then
		for i in $(seq 0 1); do
			echo "server$i log:"
			cat "$WORK_DIR/pool-minio-900$i.log"
		done
	fi

	for i in $(seq 0 1); do
		rm -f "$WORK_DIR/pool-minio-900$i.log"
	done

	return "$rv"
}

function run_test_pool_erasure_sets_ipv6() {
	start_minio_pool_erasure_sets_ipv6

	export SERVER_ENDPOINT="[::1]:9000"

from sqlmodel import Field, Session, SQLModel, create_engine, select


class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str = Field(index=True)
    age: int | None = Field(default=None, index=True)
    secret_name: str


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

connect_args = {"check_same_thread": False}

def gen_dependency(value: str) -> Generator[str, None, None]:
    yield value


async def async_gen_dependency(value: str) -> AsyncGenerator[str, None]:
    yield value


class CallableDependency:
    def __call__(self, value: str) -> str:
        return value


class CallableGenDependency:
    def __call__(self, value: str) -> Generator[str, None, None]:
        yield value

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/", summary="Create an item")
async def create_item(item: Item) -> Item:
    """
    Create an item with all the information:

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

                (jsonObject["parallelizationMethod"] as? Map<*, *>)?.let { objectMapper.valueToTree<JsonNode>(it) }
                    ?: return None

            return when (methodJsonNode.get("name")?.asText()) {
                null -> None
                None::class.simpleName -> None
                TestDistribution::class.simpleName -> TestDistribution
                TestDistributionAlpine::class.simpleName -> TestDistributionAlpine

from fastapi import FastAPI, Form
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field

app = FastAPI()


class FormModel(BaseModel):
    username: str
    lastname: str
    age: int | None = None
    tags: list[str] = ["foo", "bar"]
    alias_with: str = Field(alias="with", default="nothing")


class FormModelExtraAllow(BaseModel):
    param: str

    model_config = {"extra": "allow"}

                "aaa");
        assertQueryBuilder(MatchPhraseQueryBuilder.class,
                "{\"match_phrase\":{\"title\":{\"query\":\"aaa\",\"slop\":0,\"zero_terms_query\":\"NONE\",\"boost\":1.0}}}", //

```mermaid
flowchart LR
    subgraph global[global env]
        harry-1[harry v1]
    end
    subgraph stone-project[philosophers-stone project]
        stone(philosophers-stone) -->|requires| harry-1
    end
```

    code_block: list[str] = []
    for line_a, line_b in zip(block_a["content"], block_b["content"], strict=False):
        line_a_comment: str | None = None
        line_b_comment: str | None = None

        # Handle comments based on language
        if block_language in {
            "python",
            "py",
            "sh",
            "bash",
            "dockerfile",