🔧 chore(config.yaml): add documentation for SQLDatabase wrapper

🐛 fix(utils.py): fix import of wrapper_creator from langflow.interface.wrappers.base
🔧 chore(loading.py): add support for instantiating wrappers based on node type
🔧 chore(base.py): add support for creating SQLDatabase wrapper from URI
The config.yaml file was modified to add documentation for the SQLDatabase wrapper. In utils.py, the import of wrapper_creator from langflow.interface.wrappers.base was fixed. In loading.py, support was added for instantiating wrappers based on the node type. In base.py, support was added for creating the SQLDatabase wrapper from a URI. These changes were made to improve the functionality and maintainability of the codebase.

src/backend/langflow/config.yaml

@@ -280,6 +280,8 @@ vectorstores:
 wrappers:
   RequestsWrapper:
     documentation: ""
+  SQLDatabase:
+    documentation: ""
 output_parsers:
   StructuredOutputParser:
     documentation: "https://python.langchain.com/docs/modules/model_io/output_parsers/structured"

src/backend/langflow/interface/importing/utils.py

@@ -10,6 +10,7 @@ from langchain.chains.base import Chain
 from langchain.chat_models.base import BaseChatModel
 from langchain.tools import BaseTool
 from langflow.utils import validate
+from langflow.interface.wrappers.base import wrapper_creator
 
 
 def import_module(module_path: str) -> Any:
@@ -96,7 +97,11 @@ def import_prompt(prompt: str) -> Type[PromptTemplate]:
 
 def import_wrapper(wrapper: str) -> Any:
     """Import wrapper from wrapper name"""
-    return import_module(f"from langchain.requests import {wrapper}")
+    if (
+        isinstance(wrapper_creator.type_dict, dict)
+        and wrapper in wrapper_creator.type_dict
+    ):
+        return wrapper_creator.type_dict.get(wrapper)
 
 
 def import_toolkit(toolkit: str) -> Any:

src/backend/langflow/interface/initialize/loading.py

@@ -20,6 +20,7 @@ from langflow.interface.toolkits.base import toolkits_creator
 from langflow.interface.chains.base import chain_creator
 from langflow.interface.output_parsers.base import output_parser_creator
 from langflow.interface.retrievers.base import retriever_creator
+from langflow.interface.wrappers.base import wrapper_creator
 from langflow.interface.utils import load_file_into_dict
 from langflow.utils import validate
 from langchain.chains.base import Chain
@@ -89,10 +90,21 @@ def instantiate_based_on_type(class_object, base_type, node_type, params):
         return instantiate_retriever(node_type, class_object, params)
     elif base_type == "memory":
         return instantiate_memory(node_type, class_object, params)
+    elif base_type == "wrappers":
+        return instantiate_wrapper(node_type, class_object, params)
     else:
         return class_object(**params)
 
 
+def instantiate_wrapper(node_type, class_object, params):
+    if node_type in wrapper_creator.from_method_nodes:
+        method = wrapper_creator.from_method_nodes[node_type]
+        if class_method := getattr(class_object, method, None):
+            return class_method(**params)
+        raise ValueError(f"Method {method} not found in {class_object}")
+    return class_object(**params)
+
+
 def instantiate_output_parser(node_type, class_object, params):
     if node_type in output_parser_creator.from_method_nodes:
         method = output_parser_creator.from_method_nodes[node_type]

src/backend/langflow/interface/wrappers/base.py

@@ -1,25 +1,36 @@
 from typing import Dict, List, Optional
 
-from langchain import requests
+from langchain import requests, sql_database
 
 from langflow.interface.base import LangChainTypeCreator
 from langflow.utils.logger import logger
-from langflow.utils.util import build_template_from_class
+from langflow.utils.util import build_template_from_class, build_template_from_method
 
 
 class WrapperCreator(LangChainTypeCreator):
     type_name: str = "wrappers"
 
+    from_method_nodes = {"SQLDatabase": "from_uri"}
+
     @property
     def type_to_loader_dict(self) -> Dict:
         if self.type_dict is None:
             self.type_dict = {
-                wrapper.__name__: wrapper for wrapper in [requests.TextRequestsWrapper]
+                wrapper.__name__: wrapper
+                for wrapper in [requests.TextRequestsWrapper, sql_database.SQLDatabase]
             }
         return self.type_dict
 
     def get_signature(self, name: str) -> Optional[Dict]:
         try:
+            if name in self.from_method_nodes:
+                return build_template_from_method(
+                    name,
+                    type_to_cls_dict=self.type_to_loader_dict,
+                    add_function=True,
+                    method_name=self.from_method_nodes[name],
+                )
+
             return build_template_from_class(name, self.type_to_loader_dict)
         except ValueError as exc:
             raise ValueError("Wrapper not found") from exc