from collections.abc import Callable
from typing import Annotated

from fastapi import Body, FastAPI, HTTPException, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.routing import APIRoute


class ValidationErrorLoggingRoute(APIRoute):
    def get_route_handler(self) -> Callable:
        original_route_handler = super().get_route_handler()

        async def custom_route_handler(request: Request) -> Response:

from collections.abc import AsyncIterable
from typing import Annotated

from fastapi import FastAPI, Header
from fastapi.sse import EventSourceResponse, ServerSentEvent
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float


items = [
    Item(name="Plumbus", price=32.99),
    Item(name="Portal Gun", price=999.99),
    Item(name="Meeseeks Box", price=49.99),
]

        .containsExactly(fullpath("base/relative.jar"));
  }

  public void testGetClassName() {
    assertThat(ClassPath.getClassName("abc/d/Abc.class")).isEqualTo("abc.d.Abc");
  }

  public void testResourceInfo_of() {
    assertThat(resourceInfo(ClassPathTest.class)).isInstanceOf(ClassInfo.class);
    assertThat(resourceInfo(ClassPath.class)).isInstanceOf(ClassInfo.class);

     * <p>
     * Usage example:
     * </p>
     *
     * <pre>
     * StringUtil.decapitalize("UserId")  = "userId"
     * StringUtil.decapitalize("ABC")     = "ABC"
     * </pre>
     *
     * @param name
     *            the string to decapitalize
     * @return the decapitalized string
     */
    public static String decapitalize(final String name) {

        testDir = File.createTempFile("synonymtest", "_dir");
        testDir.delete();
        testDir.mkdirs();
        file1 = new File(testDir, "synonym.txt");
        FileUtil.writeBytes(file1.getAbsolutePath(), "abc=>123\nxyz,890".getBytes(Constants.UTF_8));
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        super.tearDown(testInfo);
        FileUtils.deleteDirectory(testDir);
    }

from collections.abc import AsyncIterable, Iterable

from fastapi import FastAPI
from fastapi.sse import EventSourceResponse
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None


items = [
    Item(name="Plumbus", description="A multi-purpose household device."),
    Item(name="Portal Gun", description="A portal opening device."),

  @Test
  fun writeAndReadEntry() {
    val creator = cache.edit("k1")!!
    creator.setString(0, "ABC")
    creator.setString(1, "DE")
    assertThat(creator.newSource(0)).isNull()
    assertThat(creator.newSource(1)).isNull()
    creator.commit()
    val snapshot = cache["k1"]!!
    snapshot.assertValue(0, "ABC")
    snapshot.assertValue(1, "DE")
  }

  @Test
  fun readAndWriteEntryAcrossCacheOpenAndClose() {

		{ObjectOpts{Name: "abc/c4test"}, cfgs[3], true},                                                                                         // 34. matches rule 2 for replication of content/metadata

  fun successfulCallEventSequence() {
    server.enqueue(MockResponse(body = "abc"))
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.body.close()

from collections.abc import Awaitable, Callable
from contextvars import ContextVar
from typing import Any

from fastapi import Depends, FastAPI, Request, Response
from fastapi.testclient import TestClient

legacy_request_state_context_var: ContextVar[dict[str, Any] | None] = ContextVar(
    "legacy_request_state_context_var", default=None
)

app = FastAPI()


async def set_up_request_state_dependency():