GenericBuilderTest.java

package dev.langchain4j.model.openai;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;

import dev.langchain4j.model.openai.OpenAiChatModel.OpenAiChatModelBuilder;

import static dev.langchain4j.model.openai.GenericBuilderTest.Params.*;
import static dev.langchain4j.model.openai.GenericBuilderTest.Builder.builder;

public class GenericBuilderTest {

    static class Temperature implements Consumer<OpenAiChatModel.OpenAiChatModelBuilder> {
        private final double temperature;

        Temperature(final double temperature) {
            this.temperature = temperature;
        }

        @Override
        public void accept(final OpenAiChatModel.OpenAiChatModelBuilder openAiChatModelBuilder) {
            openAiChatModelBuilder.temperature(temperature);
        }
    }

    static class ModelName implements Consumer<OpenAiChatModel.OpenAiChatModelBuilder> {
        private final String modelName;

        ModelName(final String modelName) {
            this.modelName = modelName;
        }

        @Override
        public void accept(final OpenAiChatModel.OpenAiChatModelBuilder openAiChatModelBuilder) {
            openAiChatModelBuilder.modelName(modelName);
        }
    }

    static class Params {
        static Temperature temperature(double temperature) {
            return new Temperature(temperature);
        }

        static ModelName modelName(String modelName) {
            return new ModelName(modelName);
        }
    }

    static class Builder<A extends Supplier<B>, B> {

        private final Supplier<A> builderSupplier;

        private final List<Consumer<A>> params = new ArrayList<>();

        Builder(final Supplier<A> builderSupplier) {
            this.builderSupplier = builderSupplier;
        }

        static <A extends Supplier<B>, B> Builder<A, B> builder(Supplier<A> builderSupplier) {
            return new Builder<>(builderSupplier);
        }

        Builder<A, B> with(Consumer<A>... params) {
            this.params.addAll(Arrays.asList(params));
            return this;
        }

        B build() {
            A builder = builderSupplier.get();
            params.forEach(param -> param.accept(builder));
            return builder.get();
        }
    }

    @Test
    void should_build_model() {
        OpenAiChatModel model = builder(OpenAiChatModelBuilder::new)
                .with(temperature(0.3), modelName("test_model")) // you can set one or more values
                .with(b -> b.apiKey("api_key")) // also using a lambda (for unknown params)
                .build();
    }
}