from enum import Enum

from fastapi import FastAPI


class ModelName(str, Enum):
    alexnet = "alexnet"
    resnet = "resnet"
    lenet = "lenet"


app = FastAPI()


@app.get("/models/{model_name}")
async def get_model(model_name: ModelName):
    if model_name is ModelName.alexnet:
        return {"model_name": model_name, "message": "Deep Learning FTW!"}

    if model_name.value == "lenet":

 *
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services} instead
 */
@Deprecated(since = "4.0.0")
public interface Source {

    /**
     * Gets a byte stream to the source contents. Closing the returned stream is the responsibility of the caller.
     *
     * @return A byte stream to the source contents, never {@code null}.
     * @throws IOException in case of IO issue

     * @param location The location to report for this use, may be {@code null}.
     */
    public StringSettingsSource(CharSequence settings, String location) {
        super(settings, location);
    }

    /**
     * Gets the character sequence of this settings source.
     *
     * @return The underlying character stream, never {@code null}.
     * @deprecated instead use {@link #getContent()}
     */
    @Deprecated

        super(message, (File) null);

        this.collisions = (collisions != null) ? collisions : new LinkedHashMap<>();
    }

    /**
     * Gets the POM files of the projects that collided.
     *
     * @return The POM files of the projects that collided, indexed by their g:a:v, never {@code null}.
     */
    public Map<String, List<File>> getCollisions() {

        slowPointer = slowPointer.getCause();
      }
      advanceSlowPointer = !advanceSlowPointer; // only advance every other iteration
    }
    return throwable;
  }

  /**
   * Gets a {@code Throwable} cause chain as a list. The first entry in the list will be {@code
   * throwable} followed by its cause hierarchy. Note that this is a snapshot of the cause chain and

     * @param type the target type to unwrap to
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Address> T unwrap(Class<T> type);

    /**
     * Gets the host name of this address.
     *
     * @return the resolved host name, or the host address if it could not be resolved
     */
    String getHostName();

    /**

     */
    public ContainerNotAvailableException(final Throwable cause) {
        super("Container is not available.");
        componentName = "container";
    }

    /**
     * Gets the name of the component that is not available.
     * @return The component name.
     */
    public String getComponentName() {
        return componentName;
    }

     * @return
     */
    private static byte[] encode(final long ts) {
        final byte[] data = new byte[8];
        SMBUtil.writeInt8(ts, data, 0);
        return data;
    }

    /**
     * Gets the timestamp value from this AV pair
     *
     * @return the timestamp
     */
    public long getTimestamp() {
        return SMBUtil.readInt8(getRaw(), 0);
    }

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def root():

   * {@link Set}, instead of the {@link Collection} specified in the {@link Multimap} interface.
   */
  @Override
  public Set<V> get(@ParametricNullness K key) {
    return (Set<V>) super.get(key);
  }

  /**
   * {@inheritDoc}
   *
   * <p>Because a {@code SetMultimap} has unique values for a given key, this method returns a