* dummy version.
   *
   * @throws UnsupportedOperationException always
   * @deprecated <b>Pass a parameter of type {@code Comparable} to use {@link
   *     ImmutableSortedSet#of(Comparable)}.</b>
   */
  @DoNotCall("Pass a parameter of type Comparable")
  @Deprecated
  public static <E> ImmutableSortedSet<E> of(E element) {
    throw new UnsupportedOperationException();
  }

# to tensorflow/ which does have these two directories.
try:
  del python
except NameError:
  pass
try:
  del core
except NameError:
  pass
try:
  del compiler
except NameError:
  pass

from fastapi.testclient import TestClient
from typing_extensions import Annotated

app = FastAPI()

T = TypeVar("T")

Dep = Annotated[T, Depends()]


class A:
    pass


class B:
    pass


@app.get("/a")
async def a(dep: Dep[A]):
    return {"cls": dep.__class__.__name__}


@app.get("/b")
async def b(dep: Dep[B]):
    return {"cls": dep.__class__.__name__}

There are several parameters that you can pass to your *path operation decorator* to configure it.

!!! warning
    Notice that these parameters are passed directly to the *path operation decorator*, not to your *path operation function*.

## Response Status Code

You can define the (HTTP) `status_code` to be used in the response of your *path operation*.

You can pass directly the `int` code, like `404`.

@app.get(
    "/a",
    response_class=Response,
    responses={500: {"description": "Error", "model": JsonApiError}},
)
async def a():
    pass  # pragma: no cover


@app.get("/b", responses={500: {"description": "Error", "model": Error}})
async def b():
    pass  # pragma: no cover


client = TestClient(app)


def test_openapi_schema():
    response = client.get("/openapi.json")

@app.get(
    "/a",
    response_class=JsonApiResponse,
    responses={500: {"description": "Error", "model": JsonApiError}},
)
async def a():
    pass  # pragma: no cover


@app.get("/b", responses={500: {"description": "Error", "model": Error}})
async def b():
    pass  # pragma: no cover


client = TestClient(app)


def test_openapi_schema():
    response = client.get("/openapi.json")

@app.get(
    "/a",
    status_code=204,
    response_class=JsonApiResponse,
    responses={500: {"description": "Error", "model": JsonApiError}},
)
async def a():
    pass


@app.get("/b", responses={204: {"description": "No Content"}})
async def b():
    pass  # pragma: no cover


client = TestClient(app)


def test_get_response():
    response = client.get("/a")
    assert response.status_code == 204, response.text

        @property
        def full_name(self) -> str:
            return f"{self.name} {self.lastname}"

        model_config = ConfigDict(from_attributes=True)

    class PersonCreate(PersonBase):
        pass

    class PersonRead(PersonBase):
        full_name: str

        model_config = {"from_attributes": True}

    app = FastAPI()

    @app.post("/people/", response_model=PersonRead)

      tmp += UnsignedLongs.remainder(longs[j], divisors[j]);
    }
    return tmp;
  }

  @Benchmark
  long parseUnsignedLong(int reps) {
    long tmp = 0;
    // Given that we make three calls per pass, we scale reps down in order
    // to do a comparable amount of work to other measurements.
    int scaledReps = reps / 3 + 1;
    for (int i = 0; i < scaledReps; i++) {
      int j = i & ARRAY_MASK;

   * of the supertype that suggests that implementations are expected to tolerate null. That said, I
   * see calls in Google code that pass a null `dir` to a FilenameFilter.... So let's declare the
   * parameter as non-nullable (since passing null to a FilenameFilter is unsafe in general), but if
   * someone still manages to pass null, let's continue to have the method work.
   *