}

  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) {
    return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
  }

  static <E extends @Nullable Object> Set<E> newHashSetWithExpectedSize(int expectedSize) {
    return Sets.newHashSetWithExpectedSize(expectedSize);
  }

  static <E extends @Nullable Object> Set<E> newConcurrentHashSet() {

import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * LocalCache emulation for GWT.
 *
 * @param <K> the base key type
 * @param <V> the base value type

    ImmutableList.Builder<Future<?>> futures = ImmutableList.builder();
    for (int i = 0; i < threadCount; i++) {
      futures.add(
          executor.submit(
              new Callable<@Nullable Void>() {
                @Override
                public @Nullable Void call() throws Exception {
                  barrier.await();
                  Integer first = graph.nodes().iterator().next();

///

The `oauth2_scheme` variable is an instance of `OAuth2PasswordBearer`, but it is also a "callable".

It could be called as:

```Python
oauth2_scheme(some, parameters)
```

So, it can be used with `Depends`.

### Use it { #use-it }

Но при этом мы хотим иметь возможность параметризовать это фиксированное содержимое.

## «Вызываемый» экземпляр { #a-callable-instance }

В Python есть способ сделать экземпляр класса «вызываемым» объектом.

Не сам класс (он уже является вызываемым), а экземпляр этого класса.

Для этого объявляем метод `__call__`:

    assertThat(result.get(0)).isEqualTo(key);
    assertThat(result.get(1)).isEqualTo(key);
    assertThat(cache.getUnchecked(key)).isEqualTo(key + suffix);
  }

  static <T> Callable<T> throwing(Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

* das Deployment
* deployen

* das SDK
* das Software Development Kit

* der `APIRouter`
* die `requirements.txt`
* das Bearer-Token
* der Breaking Change
* der Bug
* der Button
* das Callable
* der Code
* der Commit
* der Contextmanager
* die Coroutine
* die Datenbanksession
* die Festplatte
* die Domain
* die Engine
* das Fake-X
* die HTTP-GET-Methode
* das Item

    assertThat(result.get(0)).isEqualTo(key);
    assertThat(result.get(1)).isEqualTo(key);
    assertThat(cache.getUnchecked(key)).isEqualTo(key + suffix);
  }

  static <T> Callable<T> throwing(Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

///

A variável `oauth2_scheme` é uma instância de `OAuth2PasswordBearer`, mas também é "chamável" (callable).

Ela pode ser chamada como:

```Python
oauth2_scheme(some, parameters)
```

Então, pode ser usada com `Depends`.

### Use-o { #use-it }

///

La variable `oauth2_scheme` es una instance de `OAuth2PasswordBearer`, pero también es un "callable".

Podría ser llamada como:

```Python
oauth2_scheme(some, parameters)
```

Así que, puede usarse con `Depends`.

### Úsalo { #use-it }