}

        @Override
        public ToolingModelScope locateBuilderForDefaultTarget(String modelName, boolean param) throws UnknownModelException {
            return locateBuilderForTarget(defaultTarget, modelName, param);
        }

        @Override
        public ToolingModelScope locateBuilderForTarget(BuildState target, String modelName, boolean param) throws UnknownModelException {

    @Override
    public boolean canBuild(String modelName) {
        return modelName.equals("org.gradle.tooling.model.gradle.BuildInvocations");
    }

    @Override
    @SuppressWarnings("StringEquality")
    public DefaultBuildInvocations buildAll(String modelName, Project project) {
        if (!canBuild(modelName)) {
            throw new GradleException("Unknown model name " + modelName);
        }

        this.fileCollectionFactory = fileCollectionFactory;
    }

    @Override
    public boolean canBuild(String modelName) {
        return modelName.equals("org.gradle.tooling.model.build.BuildEnvironment");
    }

    @Override
    public Object buildAll(String modelName, Project target) {
        File gradleUserHomeDir = target.getGradle().getGradleUserHomeDir();

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

    @Inject
    public ModelBuilder(Problems problems) {
        this.problems = problems;
    }

    @Override
    public boolean canBuild(String modelName) {
        return DemoModel.class.getName().equals(modelName);
    }

    @Override
    public Object buildAll(String modelName, Project project) {
        problems.forNamespace("reporters.model.builder").reporting(problem -> problem
            .id("unused", "Demo model")

     */
    GradleInternal getConfiguredModel();

    ToolingModelScope locateBuilderForDefaultTarget(String modelName, boolean param);

    ToolingModelScope locateBuilderForTarget(BuildState target, String modelName, boolean param);

    ToolingModelScope locateBuilderForTarget(ProjectState target, String modelName, boolean param);

    boolean queryModelActionsRunInParallel();

    /**

                }
            }

            class CustomBuilder2 implements ToolingModelBuilder {
                boolean canBuild(String modelName) {
                    return modelName == '${CustomModel2.name}'
                }
                Object buildAll(String modelName, Project project) {
                    return new DefaultCustomModel2();
                }
            }
        """

    @Nullable
    Registration find(String modelName);

    /**
     * Locates a builder for a project-scoped model.
     */
    Builder locateForClientOperation(String modelName, boolean parameter, ProjectState target) throws UnknownModelException;

    /**
     * Locates a builder for a build-scoped model.
     */
    @Nullable
    Builder maybeLocateForBuildScope(String modelName, boolean parameter, BuildState target);

}

class CustomThing implements Serializable {
}

class CustomBuilder implements ToolingModelBuilder {
    boolean canBuild(String modelName) {
        return modelName == '${CustomModel.name}'
    }
    Object buildAll(String modelName, Project project) {
        return new CustomModel()
    }
}

class CustomPlugin implements Plugin<Project> {
    @Inject

    }

    private List<Object> getModels(BuildToolingModelController controller, List<Project> targets, String modelName, @Nullable ToolingModelParameterCarrier parameter) {
        List<Supplier<Object>> fetchActions = targets.stream()
            .map(targetProject -> (Supplier<Object>) () -> fetchModel(modelName, controller, (ProjectInternal) targetProject, parameter))