app = FastAPI()
    model = ModelWithDatetimeField(dt_field=datetime(2019, 1, 1, 8))

    @app.get("/model", response_model=ModelWithDatetimeField)
    def get_model():
        return model

    client = TestClient(app)
    with client:
        response = client.get("/model")

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":

                raise ValueError("name must end in A")
            return name

    async def get_model_c() -> ModelC:
        return ModelC(username="test-user", password="test-password")

    @app.get("/model/{name}", response_model=ModelA)
    async def get_model_a(name: str, model_c=Depends(get_model_c)):
        return {
            "name": name,
            "description": "model-a-desc",
            "foo": model_c,

     * Gets the model being wrapped.
     *
     * @return The model or {@code null} if not set.
     */
    public Model getModel() {
        return model;
    }

    /**
     * Sets the model being wrapped.
     *
     * @param model The model, may be {@code null}.
     */
    public void setModel(Model model) {
        this.model = model;
    }

    /**
     * Gets the raw model being wrapped.
     *

            if (!Objects.equals(type, other.type)) {
                return false;
            }

            Properties thisProvides = this.getModel().getProvides();
            Properties otherProvides = other.getModel().getProvides();

            return Objects.equals(thisProvides, otherProvides);
        } else {
            return false;
        }
    }

    @Override

    }

    @Nonnull
    @Override
    public Packaging getPackaging() {
        return packaging;
    }

    @Nonnull
    @Override
    public Model getModel() {
        return project.getModel().getDelegate();
    }

    @Nonnull
    @Override
    public Path getPomPath() {
        return Objects.requireNonNull(project.getFile(), "pomPath cannot be null")

        return delegate;
    }

    @Override
    public Plugin getPlugin() {
        return new Plugin() {
            @Override
            public org.apache.maven.api.model.Plugin getModel() {
                return delegate.getPlugin().getDelegate();
            }

            @Override
            public PluginDescriptor getDescriptor() {

        testInheritance(baseName, true);
    }

    public void testInheritance(String baseName, boolean fromRepo) throws IOException {
        Model parent = getModel(baseName + "-parent");

        Model child = getModel(baseName + "-child");

        if (fromRepo) {
            // when model is read from repo, a stream is used, then pomFile == null

        return project;
    }

    @Override
    public List<Dependency> getDependencies() {
        return project.getModel().getDependencies();
    }

    @Override
    public List<Dependency> getManagedDependencies() {
        DependencyManagement depMngt = project.getModel().getDependencyManagement();
        return (depMngt != null) ? Collections.unmodifiableList(depMngt.getDependencies()) : Collections.emptyList();

    /**
     * Gets the model being built. The precise state of this model depends on the event being fired.
     *
     * @return The model being built, never {@code null}.
     */
    Model getModel();

    /**
     * Gets the model building request being processed.
     *
     * @return The model building request being processed, never {@code null}.
     */
    ModelBuildingRequest getRequest();