🔥 refactor(chat_manager.py): rename filter parameter to filter_messages for clarity

🔥 refactor(custom.py): remove unused import of SQL_FORMAT_INSTRUCTIONS
🔥 refactor(custom_lists.py): remove unused import of SQLDatabase and utility_type_to_cls_dict
🔥 refactor(utilities/base.py): remove unused import of utility_type_to_cls_dict
🔥 refactor(utils/util.py): remove unused function build_template_from_parameters
The changes made are mostly removing unused imports and renaming a parameter for clarity. The import of SQL_FORMAT_INSTRUCTIONS was removed as it was not being used. The function build_template_from_parameters was removed as it was not being used.

src/backend/langflow/api/chat_manager.py

@@ -29,10 +29,10 @@ class ChatHistory(Subject):
         if not isinstance(message, FileResponse):
             self.notify()
 
-    def get_history(self, client_id: str, filter=True) -> List[ChatMessage]:
+    def get_history(self, client_id: str, filter_messages=True) -> List[ChatMessage]:
         """Get the chat history for a client."""
         if history := self.history.get(client_id, []):
-            if filter:
+            if filter_messages:
                 return [msg for msg in history if msg.type not in ["start", "stream"]]
             return history
         else:

src/backend/langflow/interface/agents/custom.py

@@ -28,7 +28,6 @@ from langchain.agents.agent_toolkits.vectorstore.prompt import (
     ROUTER_PREFIX as VECTORSTORE_ROUTER_PREFIX,
 )
 from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
-from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS as SQL_FORMAT_INSTRUCTIONS
 from langchain.base_language import BaseLanguageModel
 from langchain.memory.chat_memory import BaseChatMemory
 from langchain.sql_database import SQLDatabase
@@ -228,7 +227,7 @@ class SQLAgent(CustomAgentExecutor):
             tools=tools,  # type: ignore
             prefix=prefix,
             suffix=SQL_SUFFIX,
-            format_instructions=SQL_FORMAT_INSTRUCTIONS,
+            format_instructions=FORMAT_INSTRUCTIONS,
         )
         llm_chain = LLMChain(
             llm=llm,

src/backend/langflow/interface/custom_lists.py

@@ -9,11 +9,9 @@ from langchain import (
     memory,
     requests,
     text_splitter,
-    utilities,
 )
 from langchain.agents import agent_toolkits
 from langchain.chat_models import ChatOpenAI
-from langchain.sql_database import SQLDatabase
 
 from langflow.interface.importing.utils import import_class
 
@@ -72,9 +70,3 @@ documentloaders_type_to_cls_dict: dict[str, Any] = {
 textsplitter_type_to_cls_dict: dict[str, Any] = dict(
     inspect.getmembers(text_splitter, inspect.isclass)
 )
-
-## Utilities
-utility_type_to_cls_dict: dict[str, Any] = dict(
-    inspect.getmembers(utilities, inspect.isclass)
-)
-utility_type_to_cls_dict["SQLDatabase"] = SQLDatabase

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

@@ -71,9 +71,9 @@ def import_class(class_path: str) -> Any:
 
 
 def import_prompt(prompt: str) -> Type[PromptTemplate]:
+    """Import prompt from prompt name"""
     from langflow.interface.prompts.custom import CUSTOM_PROMPTS
 
-    """Import prompt from prompt name"""
     if prompt == "ZeroShotPrompt":
         return import_class("langchain.prompts.PromptTemplate")
     elif prompt in CUSTOM_PROMPTS:

src/backend/langflow/interface/loading.py

@@ -152,10 +152,10 @@ def instantiate_utility(node_type, class_object, params):
 
 
 def load_flow_from_json(path: str, build=True):
+    """Load flow from json file"""
     # This is done to avoid circular imports
     from langflow.graph import Graph
 
-    """Load flow from json file"""
     with open(path, "r", encoding="utf-8") as f:
         flow_graph = json.load(f)
     data_graph = flow_graph["data"]

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

@@ -4,7 +4,6 @@ from langchain import SQLDatabase, utilities
 
 from langflow.custom.customs import get_custom_nodes
 from langflow.interface.base import LangChainTypeCreator
-from langflow.interface.custom_lists import utility_type_to_cls_dict
 from langflow.interface.importing.utils import import_class
 from langflow.settings import settings
 from langflow.template.frontend_node.utilities import UtilitiesFrontendNode

src/backend/langflow/utils/util.py

@@ -10,49 +10,6 @@ from langflow.template.constants import FORCE_SHOW_FIELDS
 from langflow.utils import constants
 
 
-def build_template_from_parameters(
-    name: str, type_to_loader_dict: Dict, add_function: bool = False
-):
-    # Retrieve the function that matches the provided name
-    func = None
-    for _, v in type_to_loader_dict.items():
-        if v.__name__ == name:
-            func = v
-            break
-
-    if func is None:
-        raise ValueError(f"{name} not found")
-
-    # Process parameters
-    parameters = func.__annotations__
-    variables = {}
-    for param_name, param_type in parameters.items():
-        if param_name in ["return", "kwargs"]:
-            continue
-
-        variables[param_name] = {
-            "type": param_type.__name__,
-            "default": parameters[param_name].__repr_args__()[0][1],
-            # Op
-            "placeholder": "",
-        }
-
-    # Get the base classes of the return type
-    return_type = parameters.get("return")
-    base_classes = get_base_classes(return_type) if return_type else []
-    if add_function:
-        base_classes.append("function")
-
-    # Get the function's docstring
-    docs = inspect.getdoc(func) or ""
-
-    return {
-        "template": format_dict(variables, name),
-        "description": docs["Description"],  # type: ignore
-        "base_classes": base_classes,
-    }
-
-
 def build_template_from_function(
     name: str, type_to_loader_dict: Dict, add_function: bool = False
 ):