set: list,
    UUID: str,
    Url: str,
    AnyUrl: str,
}


def generate_encoders_by_class_tuples(
    type_encoder_map: dict[Any, Callable[[Any], Any]],
) -> dict[Callable[[Any], Any], tuple[Any, ...]]:
    encoders_by_class_tuples: dict[Callable[[Any], Any], tuple[Any, ...]] = defaultdict(
        tuple
    )
    for type_, encoder in type_encoder_map.items():

            The parameter is available only for compatibility.
            """
        ),
    ] = ...,
    *,
    default_factory: Annotated[
        Callable[[], Any] | None,
        Doc(
            """
            A callable to generate the default value.

            This doesn't affect `Path` parameters as the value is always required.
            The parameter is available only for compatibility.

    assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofSeconds(12));
  }

  public void testScheduleCallable() throws Exception {
    Callable<String> callable = () -> "hello";

    ListenableScheduledFuture<String> future =
        executorService.schedule(callable, Duration.ofMinutes(12));

    assertThat(future.get()).isEqualTo("hello");
    assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);

So, a Python class is also a **callable**.

Then, in **FastAPI**, you could use a Python class as a dependency.

What FastAPI actually checks is that it is a "callable" (function, class or anything else) and the parameters defined.

    Callable<@Nullable Void> completeSuccessfullyRunnable =
        () -> {
          if (currentFuture.get().set("set")) {
            numSuccessfulSetCalls.incrementAndGet();
          }
          awaitUnchecked(barrier);
          return null;
        };
    Callable<@Nullable Void> completeExceptionallyRunnable =
        new Callable<@Nullable Void>() {

    Callable<@Nullable Void> completeSuccessfullyRunnable =
        () -> {
          if (currentFuture.get().set("set")) {
            numSuccessfulSetCalls.incrementAndGet();
          }
          awaitUnchecked(barrier);
          return null;
        };
    Callable<@Nullable Void> completeExceptionallyRunnable =
        new Callable<@Nullable Void>() {

# dependencies' AsyncExitStack
def request_response(
    func: Callable[[Request], Awaitable[Response] | Response],
) -> ASGIApp:
    """
    Takes a function or coroutine `func(request) -> response`,
    and returns an ASGI application.
    """
    f: Callable[[Request], Awaitable[Response]] = (
        func  # type: ignore[assignment]  # ty: ignore[unused-ignore-comment]

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;

```

在這個例子中，`fluffy` 是 `Cat` 類別的一個實例。

而要建立 `fluffy`，你其實是在「呼叫」`Cat`。

所以，Python 類別本身也是一種 **callable**。

因此，在 **FastAPI** 中，你可以將 Python 類別作為相依性。

FastAPI 其實檢查的是它是否為「callable」（函式、類別或其他），以及它所定義的參數。

如果你在 **FastAPI** 中傳入一個「callable」作為相依性，FastAPI 會分析該「callable」的參數，並以與路徑操作函式參數相同的方式來處理它們，包括子相依性。

這也適用於完全沒有參數的 callable，就和沒有參數的路徑操作函式一樣。

接著，我們可以把上面的相依項（dependable）`common_parameters` 改成類別 `CommonQueryParams`：

    checkNotNull(service);
    checkNotNull(nameSupplier);
    return new WrappingExecutorService(service) {
      @Override
      protected <T extends @Nullable Object> Callable<T> wrapTask(Callable<T> callable) {
        return threadRenaming(callable, nameSupplier);
      }

      @Override
      protected Runnable wrapTask(Runnable command) {
        return threadRenaming(command, nameSupplier);
      }