add python-langchain-tools generator to generate langchain tools from spec

Author: abhishekmsingh

bin/configs/python-langchain-tools-petstore-new.yaml

@@ -0,0 +1,6 @@
+generatorName: python-langchain-tools
+outputDir: samples/client/petstore/python/langchain/tools
+inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore.yaml
+templateDir: modules/openapi-generator/src/main/resources/python-langchain-tools
+additionalProperties:
+  hideGenerationTimestamp: "true"

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/PythonLangchainToolsClientCodegen.java

@@ -0,0 +1,94 @@
+package org.openapitools.codegen.languages;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+
+import org.openapitools.codegen.SupportingFile;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PythonLangchainToolsClientCodegen extends PythonClientCodegen {
+    public static final String PROJECT_NAME = "projectName";
+
+    private final Logger LOGGER = LoggerFactory.getLogger(PythonLangchainToolsClientCodegen.class);
+
+    public PythonLangchainToolsClientCodegen() {
+        super();
+        apiTemplateFiles.put("api_tools.mustache", "_tools.py");
+        supportingFiles.add(new SupportingFile("all_tools.mustache", "", "all_tools.py"));
+    }
+
+    @Override
+    public String getName() {
+        return "python-langchain-tools";
+    }
+
+    @Override
+    public String getHelp() {
+        return "Generates a Python client for LangChain agent tools, grouped by tags.";
+    }
+
+    @Override
+    public String apiFileFolder() {
+        return outputFolder + File.separator + apiPackage().replace('.', File.separatorChar);
+    }
+
+    @Override
+    public String modelFileFolder() {
+        return outputFolder + File.separator + modelPackage().replace('.', File.separatorChar);
+    }
+
+    @Override
+    public void processOpts() {
+        super.processOpts();
+
+        // Now that packageName is processed and available, we can add the supporting file
+        // for the tools package __init__.py in the correct directory.
+        final String toolsPackagePath = packageName.replace(".", File.separator) + File.separator + "tools";
+        supportingFiles.add(new SupportingFile("init.mustache", toolsPackagePath, "__init__.py"));
+    }
+
+    @Override
+    public boolean isEnablePostProcessFile() {
+        return true;
+    }
+
+    /**
+     * This is a way to add a dependency without duplicating the parent template.
+     */
+    @Override
+    public void postProcessFile(File file, String fileType) {
+        super.postProcessFile(file, fileType);
+        if (file == null) {
+            return;
+        }
+        final String filename = file.getName();
+        if ("requirements.txt".equals(filename)) {
+            try {
+                String langchainDep = "\nlangchain >=0.3, <0.4\n";
+                Files.write(file.toPath(), langchainDep.getBytes(StandardCharsets.UTF_8), StandardOpenOption.APPEND);
+            } catch (IOException e) {
+                throw new RuntimeException("Unable to write to requirements.txt", e);
+            }
+        }
+    }
+
+    /**
+     * Overriding this method to change the output location of our tool files.
+     */
+    @Override
+    public String apiFilename(String templateName, String tag) {
+        final String originalFilename = super.apiFilename(templateName, tag);
+
+        if ("api_tools.mustache".equals(templateName)) {
+            return originalFilename.replace(apiPackage().replace(".", File.separator),
+                packageName.replace(".", File.separator) + File.separator + "tools");
+        }
+
+        return originalFilename;
+    }
+
+}

modules/openapi-generator/src/main/resources/META-INF/services/org.openapitools.codegen.CodegenConfig

@@ -118,6 +118,7 @@ org.openapitools.codegen.languages.PythonFastAPIServerCodegen
 org.openapitools.codegen.languages.PythonFlaskConnexionServerCodegen
 org.openapitools.codegen.languages.PythonAiohttpConnexionServerCodegen
 org.openapitools.codegen.languages.PythonBluePlanetServerCodegen
+org.openapitools.codegen.languages.PythonLangchainToolsClientCodegen
 org.openapitools.codegen.languages.RClientCodegen
 org.openapitools.codegen.languages.RubyClientCodegen
 org.openapitools.codegen.languages.RubyOnRailsServerCodegen

modules/openapi-generator/src/main/resources/python-langchain-tools/README.mustache

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+An aggregator for all generated LangChain tools.
+
+This file provides a single list, `all_tools`, that you can import and
+provide to your LangChain agent.
+"""
+from typing import List
+from langchain.tools import StructuredTool
+
+from {{packageName}}.api_client import ApiClient
+from {{packageName}}.configuration import Configuration
+
+# Import the factory functions from each tool module
+{{#apiInfo}}
+{{#apis}}
+from {{packageName}}.tools.{{classFilename}}_tools import get_{{classVarName}}_tools
+{{/apis}}
+{{/apiInfo}}
+
+def get_all_tools() -> List[StructuredTool]:
+    """
+    Initializes the API client and aggregates tools from all API modules.
+    """
+    # TODO: You may need to customize this based on your API's authentication needs.
+    configuration = Configuration(host="{{{serverUrl}}}")
+
+    all_tools_list = []
+
+    with ApiClient(configuration) as api_client:
+        {{#apiInfo}}
+        {{#apis}}
+            all_tools_list.extend(get_{{classVarName}}_tools(api_client))
+        {{/apis}}
+        {{/apiInfo}}
+
+    return all_tools_list
+
+# A pre-initialized list of all tools for convenience.
+all_tools = get_all_tools()

modules/openapi-generator/src/main/resources/python-langchain-tools/all_tools.mustache

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+from typing import List
+from langchain.tools import StructuredTool
+from {{packageName}}.api_client import ApiClient
+from {{packageName}}.api.{{classFilename}} import {{classname}}
+
+def get_{{classVarName}}_tools(api_client: ApiClient) -> List[StructuredTool]:
+    """A factory function to create and return tools for the {{classname}} API."""
+
+    api_instance = {{classname}}(api_client)
+    tools = []
+    {{#operations}}
+    {{#operation}}
+
+    {{operationId}}_tool = StructuredTool.from_function(
+        func=api_instance.{{nickname}},
+        name="{{operationId}}",
+        description="{{{summary}}}"
+    )
+    tools.append({{operationId}}_tool)
+    {{/operation}}
+    {{/operations}}
+
+    return tools

modules/openapi-generator/src/main/resources/python-langchain-tools/api_tools.mustache

@@ -0,0 +1,31 @@
+package org.openapitools.codegen.options;
+
+import org.openapitools.codegen.CodegenConstants;
+import org.openapitools.codegen.languages.PythonLangchainToolsClientCodegen;
+
+import com.google.common.collect.ImmutableMap;
+
+import java.util.Map;
+
+public class PythonLangchainToolsClientCodegenOptionsProvider implements OptionsProvider {
+    public static final String PROJECT_NAME_VALUE = "OpenAPI";
+
+    @Override
+    public String getLanguage() {
+        return "python-langchain-tools";
+    }
+
+    @Override
+    public Map<String, String> createOptions() {
+        ImmutableMap.Builder<String, String> builder = new ImmutableMap.Builder<String, String>();
+        return builder
+                .put(PythonLangchainToolsClientCodegen.PROJECT_NAME, PROJECT_NAME_VALUE)
+                .build();
+    }
+
+    @Override
+    public boolean isServer() {
+        return false;
+    }
+}
+

modules/openapi-generator/src/main/resources/python-langchain-tools/init.mustache

@@ -0,0 +1,29 @@
+package org.openapitools.codegen.python.langchain.tools;
+
+import org.openapitools.codegen.*;
+import org.openapitools.codegen.languages.PythonLangchainToolsClientCodegen;
+import io.swagger.models.*;
+import io.swagger.models.properties.*;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@SuppressWarnings("static-method")
+public class PythonLangchainToolsClientCodegenModelTest {
+
+    @Test(description = "convert a simple java model")
+    public void simpleModelTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("id", new LongProperty())
+                .property("name", new StringProperty())
+                .required("id")
+                .required("name");
+        final DefaultCodegen codegen = new PythonLangchainToolsClientCodegen();
+
+        // TODO: Complete this test.
+        Assert.fail("Not implemented.");
+    }
+
+}
+

modules/openapi-generator/src/test/java/org/openapitools/codegen/options/PythonLangchainToolsClientCodegenOptionsProvider.java

@@ -0,0 +1,30 @@
+package org.openapitools.codegen.python.langchain.tools;
+
+import org.openapitools.codegen.AbstractOptionsTest;
+import org.openapitools.codegen.CodegenConfig;
+import org.openapitools.codegen.languages.PythonLangchainToolsClientCodegen;
+import org.openapitools.codegen.options.PythonLangchainToolsClientCodegenOptionsProvider;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class PythonLangchainToolsClientCodegenOptionsTest extends AbstractOptionsTest {
+    private PythonLangchainToolsClientCodegen codegen = mock(PythonLangchainToolsClientCodegen.class, mockSettings);
+
+    public PythonLangchainToolsClientCodegenOptionsTest() {
+        super(new PythonLangchainToolsClientCodegenOptionsProvider());
+    }
+
+    @Override
+    protected CodegenConfig getCodegenConfig() {
+        return codegen;
+    }
+
+    @SuppressWarnings("unused")
+    @Override
+    protected void verifyOptions() {
+        // TODO: Complete options using Mockito
+        // verify(codegen).someMethod(arguments)
+    }
+}
+