yield
    # Clean up the ML models and release the resources
    ml_models.clear()


app = FastAPI(lifespan=lifespan)


@app.get("/predict")
async def predict(x: float):
    result = ml_models["answer_to_everything"](x)

      assertEquals(
          arraySize * Long.SIZE, BloomFilter.create(unencodedCharsFunnel(), i, fpp).bitSize());
    }
  }

  /**
   * Tests that bitSize() can be used to predict the serialization size produced by writeTo().
   *
   * <p>The serialization format consists of a 6-byte header (1 byte strategy, 1 byte hash

        and `Model.predict()` to `"auto"`, which defaults to `verbose=1` for
        most cases and defaults to `verbose=2` when used with
        `ParameterServerStrategy` or with interactive logging disabled.
    *   Argument `jit_compile` in `Model.compile()` now applies to
        `Model.evaluate()` and `Model.predict()`. Setting `jit_compile=True` in

    yield
    # Clean up the ML models and release the resources
    ml_models.clear()


app = FastAPI(lifespan=lifespan)


@app.get("/predict")
async def predict(x: float):
    result = ml_models["answer_to_everything"](x)
    return {"result": result}
```

**Note**: This is the recommended way going forward, instead of using `startup` and `shutdown` events.

      Predicate<E> combinedPredicate = Predicates.and(filtered.predicate, predicate);
      return new FilteredSet<>((Set<E>) filtered.unfiltered, combinedPredicate);
    }

    return new FilteredSet<>(checkNotNull(unfiltered), checkNotNull(predicate));
  }

  /**
   * Returns the elements of a {@code SortedSet}, {@code unfiltered}, that satisfy a predicate. The

      Predicate<E> combinedPredicate = Predicates.and(filtered.predicate, predicate);
      return new FilteredSet<>((Set<E>) filtered.unfiltered, combinedPredicate);
    }

    return new FilteredSet<>(checkNotNull(unfiltered), checkNotNull(predicate));
  }

  /**
   * Returns the elements of a {@code SortedSet}, {@code unfiltered}, that satisfy a predicate. The

   * }
   * }
   *
   * <p>Note that if any input list is empty, the Cartesian product will also be empty. If no lists
   * at all are provided (an empty list), the resulting Cartesian product has one element, an empty
   * list (counter-intuitive, but mathematically consistent).
   *
   * <p><i>Performance notes:</i> while the cartesian product of lists of size {@code m, n, p} is a

 * @author Jared Levy
 */
@GwtIncompatible // untested
@NullUnmarked
public class MultimapsFilterEntriesAsMapTest extends AbstractMultimapAsMapImplementsMapTest {
  private static final Predicate<Entry<String, Integer>> PREDICATE =
      new Predicate<Entry<String, Integer>>() {
        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !Objects.equals(entry.getKey(), "badkey") && entry.getValue() != 55556;

    <T extends @Nullable Object> Predicate<T> withNarrowedType() {
      return (Predicate<T>) this;
    }
  }

  /**
   * @see Predicates#not(Predicate)
   */
  private static final class NotPredicate<T extends @Nullable Object>
      implements Predicate<T>, Serializable {
    final Predicate<T> predicate;

    NotPredicate(Predicate<T> predicate) {
      this.predicate = checkNotNull(predicate);

    <T extends @Nullable Object> Predicate<T> withNarrowedType() {
      return (Predicate<T>) this;
    }
  }

  /**
   * @see Predicates#not(Predicate)
   */
  private static final class NotPredicate<T extends @Nullable Object>
      implements Predicate<T>, Serializable {
    final Predicate<T> predicate;

    NotPredicate(Predicate<T> predicate) {
      this.predicate = checkNotNull(predicate);