langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/tools/google_serper_api.py

@@ -1,115 +0,0 @@
-from typing import Any
-
-from langchain.tools import StructuredTool
-from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import (
-    DictInput,
-    DropdownInput,
-    IntInput,
-    MultilineInput,
-    SecretStrInput,
-)
-from langflow.schema.data import Data
-
-
-class QuerySchema(BaseModel):
-    query: str = Field(..., description="The query to search for.")
-    query_type: str = Field(
-        "search",
-        description="The type of search to perform (e.g., 'news' or 'search').",
-    )
-    k: int = Field(4, description="The number of results to return.")
-    query_params: dict[str, Any] = Field({}, description="Additional query parameters to pass to the API.")
-
-
-class GoogleSerperAPIComponent(LCToolComponent):
-    display_name = "Google Serper API [DEPRECATED]"
-    description = "Call the Serper.dev Google Search API."
-    name = "GoogleSerperAPI"
-    icon = "Google"
-    legacy = True
-    inputs = [
-        SecretStrInput(name="serper_api_key", display_name="Serper API Key", required=True),
-        MultilineInput(
-            name="query",
-            display_name="Query",
-        ),
-        IntInput(name="k", display_name="Number of results", value=4, required=True),
-        DropdownInput(
-            name="query_type",
-            display_name="Query Type",
-            required=False,
-            options=["news", "search"],
-            value="search",
-        ),
-        DictInput(
-            name="query_params",
-            display_name="Query Params",
-            required=False,
-            value={
-                "gl": "us",
-                "hl": "en",
-            },
-            list=True,
-        ),
-    ]
-
-    def run_model(self) -> Data | list[Data]:
-        wrapper = self._build_wrapper(self.k, self.query_type, self.query_params)
-        results = wrapper.results(query=self.query)
-
-        # Adjust the extraction based on the `type`
-        if self.query_type == "search":
-            list_results = results.get("organic", [])
-        elif self.query_type == "news":
-            list_results = results.get("news", [])
-        else:
-            list_results = []
-
-        data_list = []
-        for result in list_results:
-            result["text"] = result.pop("snippet", "")
-            data_list.append(Data(data=result))
-        self.status = data_list
-        return data_list
-
-    def build_tool(self) -> Tool:
-        return StructuredTool.from_function(
-            name="google_search",
-            description="Search Google for recent results.",
-            func=self._search,
-            args_schema=self.QuerySchema,
-        )
-
-    def _build_wrapper(
-        self,
-        k: int = 5,
-        query_type: str = "search",
-        query_params: dict | None = None,
-    ) -> GoogleSerperAPIWrapper:
-        wrapper_args = {
-            "serper_api_key": self.serper_api_key,
-            "k": k,
-            "type": query_type,
-        }
-
-        # Add query_params if provided
-        if query_params:
-            wrapper_args.update(query_params)  # Merge with additional query params
-
-        # Dynamically pass parameters to the wrapper
-        return GoogleSerperAPIWrapper(**wrapper_args)
-
-    def _search(
-        self,
-        query: str,
-        k: int = 5,
-        query_type: str = "search",
-        query_params: dict | None = None,
-    ) -> dict:
-        wrapper = self._build_wrapper(k, query_type, query_params)
-        return wrapper.results(query=query)

langflow/components/tools/python_code_structured_tool.py

@@ -1,327 +0,0 @@
-import ast
-import json
-from typing import Any
-
-from langchain.agents import Tool
-from langchain_core.tools import StructuredTool
-from pydantic.v1 import Field, create_model
-from pydantic.v1.fields import Undefined
-from typing_extensions import override
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.inputs.inputs import BoolInput, DropdownInput, FieldTypes, HandleInput, MessageTextInput, MultilineInput
-from langflow.io import Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.dotdict import dotdict
-
-
-class PythonCodeStructuredTool(LCToolComponent):
-    DEFAULT_KEYS = [
-        "code",
-        "_type",
-        "text_key",
-        "tool_code",
-        "tool_name",
-        "tool_description",
-        "return_direct",
-        "tool_function",
-        "global_variables",
-        "_classes",
-        "_functions",
-    ]
-    display_name = "Python Code Structured"
-    description = "structuredtool dataclass code to tool"
-    documentation = "https://python.langchain.com/docs/modules/tools/custom_tools/#structuredtool-dataclass"
-    name = "PythonCodeStructuredTool"
-    icon = "Python"
-    field_order = ["name", "description", "tool_code", "return_direct", "tool_function"]
-    legacy: bool = True
-
-    inputs = [
-        MultilineInput(
-            name="tool_code",
-            display_name="Tool Code",
-            info="Enter the dataclass code.",
-            placeholder="def my_function(args):\n    pass",
-            required=True,
-            real_time_refresh=True,
-            refresh_button=True,
-        ),
-        MessageTextInput(
-            name="tool_name",
-            display_name="Tool Name",
-            info="Enter the name of the tool.",
-            required=True,
-        ),
-        MessageTextInput(
-            name="tool_description",
-            display_name="Description",
-            info="Enter the description of the tool.",
-            required=True,
-        ),
-        BoolInput(
-            name="return_direct",
-            display_name="Return Directly",
-            info="Should the tool return the function output directly?",
-        ),
-        DropdownInput(
-            name="tool_function",
-            display_name="Tool Function",
-            info="Select the function for additional expressions.",
-            options=[],
-            required=True,
-            real_time_refresh=True,
-            refresh_button=True,
-        ),
-        HandleInput(
-            name="global_variables",
-            display_name="Global Variables",
-            info="Enter the global variables or Create Data Component.",
-            input_types=["Data"],
-            field_type=FieldTypes.DICT,
-            is_list=True,
-        ),
-        MessageTextInput(name="_classes", display_name="Classes", advanced=True),
-        MessageTextInput(name="_functions", display_name="Functions", advanced=True),
-    ]
-
-    outputs = [
-        Output(display_name="Tool", name="result_tool", method="build_tool"),
-    ]
-
-    @override
-    async def update_build_config(
-        self, build_config: dotdict, field_value: Any, field_name: str | None = None
-    ) -> dotdict:
-        if field_name is None:
-            return build_config
-
-        if field_name not in {"tool_code", "tool_function"}:
-            return build_config
-
-        try:
-            named_functions = {}
-            [classes, functions] = self._parse_code(build_config["tool_code"]["value"])
-            existing_fields = {}
-            if len(build_config) > len(self.DEFAULT_KEYS):
-                for key in build_config.copy():
-                    if key not in self.DEFAULT_KEYS:
-                        existing_fields[key] = build_config.pop(key)
-
-            names = []
-            for func in functions:
-                named_functions[func["name"]] = func
-                names.append(func["name"])
-
-                for arg in func["args"]:
-                    field_name = f"{func['name']}|{arg['name']}"
-                    if field_name in existing_fields:
-                        build_config[field_name] = existing_fields[field_name]
-                        continue
-
-                    field = MessageTextInput(
-                        display_name=f"{arg['name']}: Description",
-                        name=field_name,
-                        info=f"Enter the description for {arg['name']}",
-                        required=True,
-                    )
-                    build_config[field_name] = field.to_dict()
-            build_config["_functions"]["value"] = json.dumps(named_functions)
-            build_config["_classes"]["value"] = json.dumps(classes)
-            build_config["tool_function"]["options"] = names
-        except Exception as e:  # noqa: BLE001
-            self.status = f"Failed to extract names: {e}"
-            logger.debug(self.status, exc_info=True)
-            build_config["tool_function"]["options"] = ["Failed to parse", str(e)]
-        return build_config
-
-    async def build_tool(self) -> Tool:
-        local_namespace = {}  # type: ignore[var-annotated]
-        modules = self._find_imports(self.tool_code)
-        import_code = ""
-        for module in modules["imports"]:
-            import_code += f"global {module}\nimport {module}\n"
-        for from_module in modules["from_imports"]:
-            for alias in from_module.names:
-                import_code += f"global {alias.name}\n"
-            import_code += (
-                f"from {from_module.module} import {', '.join([alias.name for alias in from_module.names])}\n"
-            )
-        exec(import_code, globals())
-        exec(self.tool_code, globals(), local_namespace)
-
-        class PythonCodeToolFunc:
-            params: dict = {}
-
-            def run(**kwargs):
-                for key, arg in kwargs.items():
-                    if key not in PythonCodeToolFunc.params:
-                        PythonCodeToolFunc.params[key] = arg
-                return local_namespace[self.tool_function](**PythonCodeToolFunc.params)
-
-        globals_ = globals()
-        local = {}
-        local[self.tool_function] = PythonCodeToolFunc
-        globals_.update(local)
-
-        if isinstance(self.global_variables, list):
-            for data in self.global_variables:
-                if isinstance(data, Data):
-                    globals_.update(data.data)
-        elif isinstance(self.global_variables, dict):
-            globals_.update(self.global_variables)
-
-        classes = json.loads(self._attributes["_classes"])
-        for class_dict in classes:
-            exec("\n".join(class_dict["code"]), globals_)
-
-        named_functions = json.loads(self._attributes["_functions"])
-        schema_fields = {}
-
-        for attr in self._attributes:
-            if attr in self.DEFAULT_KEYS:
-                continue
-
-            func_name = attr.split("|")[0]
-            field_name = attr.split("|")[1]
-            func_arg = self._find_arg(named_functions, func_name, field_name)
-            if func_arg is None:
-                msg = f"Failed to find arg: {field_name}"
-                raise ValueError(msg)
-
-            field_annotation = func_arg["annotation"]
-            field_description = self._get_value(self._attributes[attr], str)
-
-            if field_annotation:
-                exec(f"temp_annotation_type = {field_annotation}", globals_)
-                schema_annotation = globals_["temp_annotation_type"]
-            else:
-                schema_annotation = Any
-            schema_fields[field_name] = (
-                schema_annotation,
-                Field(
-                    default=func_arg.get("default", Undefined),
-                    description=field_description,
-                ),
-            )
-
-        if "temp_annotation_type" in globals_:
-            globals_.pop("temp_annotation_type")
-
-        python_code_tool_schema = None
-        if schema_fields:
-            python_code_tool_schema = create_model("PythonCodeToolSchema", **schema_fields)
-
-        return StructuredTool.from_function(
-            func=local[self.tool_function].run,
-            args_schema=python_code_tool_schema,
-            name=self.tool_name,
-            description=self.tool_description,
-            return_direct=self.return_direct,
-        )
-
-    async def update_frontend_node(self, new_frontend_node: dict, current_frontend_node: dict):
-        """This function is called after the code validation is done."""
-        frontend_node = await super().update_frontend_node(new_frontend_node, current_frontend_node)
-        frontend_node["template"] = await self.update_build_config(
-            frontend_node["template"],
-            frontend_node["template"]["tool_code"]["value"],
-            "tool_code",
-        )
-        frontend_node = await super().update_frontend_node(new_frontend_node, current_frontend_node)
-        for key in frontend_node["template"]:
-            if key in self.DEFAULT_KEYS:
-                continue
-            frontend_node["template"] = await self.update_build_config(
-                frontend_node["template"], frontend_node["template"][key]["value"], key
-            )
-            frontend_node = await super().update_frontend_node(new_frontend_node, current_frontend_node)
-        return frontend_node
-
-    def _parse_code(self, code: str) -> tuple[list[dict], list[dict]]:
-        parsed_code = ast.parse(code)
-        lines = code.split("\n")
-        classes = []
-        functions = []
-        for node in parsed_code.body:
-            if isinstance(node, ast.ClassDef):
-                class_lines = lines[node.lineno - 1 : node.end_lineno]
-                class_lines[-1] = class_lines[-1][: node.end_col_offset]
-                class_lines[0] = class_lines[0][node.col_offset :]
-                classes.append(
-                    {
-                        "name": node.name,
-                        "code": class_lines,
-                    }
-                )
-                continue
-
-            if not isinstance(node, ast.FunctionDef):
-                continue
-
-            func = {"name": node.name, "args": []}
-            for arg in node.args.args:
-                if arg.lineno != arg.end_lineno:
-                    msg = "Multiline arguments are not supported"
-                    raise ValueError(msg)
-
-                func_arg = {
-                    "name": arg.arg,
-                    "annotation": None,
-                }
-
-                for default in node.args.defaults:
-                    if (
-                        arg.lineno > default.lineno
-                        or arg.col_offset > default.col_offset
-                        or (
-                            arg.end_lineno is not None
-                            and default.end_lineno is not None
-                            and arg.end_lineno < default.end_lineno
-                        )
-                        or (
-                            arg.end_col_offset is not None
-                            and default.end_col_offset is not None
-                            and arg.end_col_offset < default.end_col_offset
-                        )
-                    ):
-                        continue
-
-                    if isinstance(default, ast.Name):
-                        func_arg["default"] = default.id
-                    elif isinstance(default, ast.Constant):
-                        func_arg["default"] = str(default.value) if default.value is not None else None
-
-                if arg.annotation:
-                    annotation_line = lines[arg.annotation.lineno - 1]
-                    annotation_line = annotation_line[: arg.annotation.end_col_offset]
-                    annotation_line = annotation_line[arg.annotation.col_offset :]
-                    func_arg["annotation"] = annotation_line
-                    if isinstance(func_arg["annotation"], str) and func_arg["annotation"].count("=") > 0:
-                        func_arg["annotation"] = "=".join(func_arg["annotation"].split("=")[:-1]).strip()
-                if isinstance(func["args"], list):
-                    func["args"].append(func_arg)
-            functions.append(func)
-
-        return classes, functions
-
-    def _find_imports(self, code: str) -> dotdict:
-        imports: list[str] = []
-        from_imports = []
-        parsed_code = ast.parse(code)
-        for node in parsed_code.body:
-            if isinstance(node, ast.Import):
-                imports.extend(alias.name for alias in node.names)
-            elif isinstance(node, ast.ImportFrom):
-                from_imports.append(node)
-        return dotdict({"imports": imports, "from_imports": from_imports})
-
-    def _get_value(self, value: Any, annotation: Any) -> Any:
-        return value if isinstance(value, annotation) else value["value"]
-
-    def _find_arg(self, named_functions: dict, func_name: str, arg_name: str) -> dict | None:
-        for arg in named_functions[func_name]["args"]:
-            if arg["name"] == arg_name:
-                return arg
-        return None

langflow/components/tools/python_repl.py

@@ -1,97 +0,0 @@
-import importlib
-
-from langchain.tools import StructuredTool
-from langchain_core.tools import ToolException
-from langchain_experimental.utilities import PythonREPL
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import StrInput
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-
-
-class PythonREPLToolComponent(LCToolComponent):
-    display_name = "Python REPL [DEPRECATED]"
-    description = "A tool for running Python code in a REPL environment."
-    name = "PythonREPLTool"
-    icon = "Python"
-    legacy = True
-
-    inputs = [
-        StrInput(
-            name="name",
-            display_name="Tool Name",
-            info="The name of the tool.",
-            value="python_repl",
-        ),
-        StrInput(
-            name="description",
-            display_name="Tool Description",
-            info="A description of the tool.",
-            value="A Python shell. Use this to execute python commands. "
-            "Input should be a valid python command. "
-            "If you want to see the output of a value, you should print it out with `print(...)`.",
-        ),
-        StrInput(
-            name="global_imports",
-            display_name="Global Imports",
-            info="A comma-separated list of modules to import globally, e.g. 'math,numpy'.",
-            value="math",
-        ),
-        StrInput(
-            name="code",
-            display_name="Python Code",
-            info="The Python code to execute.",
-            value="print('Hello, World!')",
-        ),
-    ]
-
-    class PythonREPLSchema(BaseModel):
-        code: str = Field(..., description="The Python code to execute.")
-
-    def get_globals(self, global_imports: str | list[str]) -> dict:
-        global_dict = {}
-        if isinstance(global_imports, str):
-            modules = [module.strip() for module in global_imports.split(",")]
-        elif isinstance(global_imports, list):
-            modules = global_imports
-        else:
-            msg = "global_imports must be either a string or a list"
-            raise TypeError(msg)
-
-        for module in modules:
-            try:
-                imported_module = importlib.import_module(module)
-                global_dict[imported_module.__name__] = imported_module
-            except ImportError as e:
-                msg = f"Could not import module {module}"
-                raise ImportError(msg) from e
-        return global_dict
-
-    def build_tool(self) -> Tool:
-        globals_ = self.get_globals(self.global_imports)
-        python_repl = PythonREPL(_globals=globals_)
-
-        def run_python_code(code: str) -> str:
-            try:
-                return python_repl.run(code)
-            except Exception as e:
-                logger.debug("Error running Python code", exc_info=True)
-                raise ToolException(str(e)) from e
-
-        tool = StructuredTool.from_function(
-            name=self.name,
-            description=self.description,
-            func=run_python_code,
-            args_schema=self.PythonREPLSchema,
-        )
-
-        self.status = f"Python REPL Tool created with global imports: {self.global_imports}"
-        return tool
-
-    def run_model(self) -> list[Data]:
-        tool = self.build_tool()
-        result = tool.run(self.code)
-        return [Data(data={"result": result})]

langflow/components/tools/search_api.py

@@ -1,87 +0,0 @@
-from typing import Any
-
-from langchain.tools import StructuredTool
-from langchain_community.utilities.searchapi import SearchApiAPIWrapper
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import DictInput, IntInput, MessageTextInput, MultilineInput, SecretStrInput
-from langflow.schema.data import Data
-
-
-class SearchAPIComponent(LCToolComponent):
-    display_name: str = "Search API [DEPRECATED]"
-    description: str = "Call the searchapi.io API with result limiting"
-    name = "SearchAPI"
-    documentation: str = "https://www.searchapi.io/docs/google"
-    icon = "SearchAPI"
-    legacy = True
-
-    inputs = [
-        MessageTextInput(name="engine", display_name="Engine", value="google"),
-        SecretStrInput(name="api_key", display_name="SearchAPI API Key", required=True),
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-        ),
-        DictInput(name="search_params", display_name="Search parameters", advanced=True, is_list=True),
-        IntInput(name="max_results", display_name="Max Results", value=5, advanced=True),
-        IntInput(name="max_snippet_length", display_name="Max Snippet Length", value=100, advanced=True),
-    ]
-
-    class SearchAPISchema(BaseModel):
-        query: str = Field(..., description="The search query")
-        params: dict[str, Any] = Field(default_factory=dict, description="Additional search parameters")
-        max_results: int = Field(5, description="Maximum number of results to return")
-        max_snippet_length: int = Field(100, description="Maximum length of each result snippet")
-
-    def _build_wrapper(self):
-        return SearchApiAPIWrapper(engine=self.engine, searchapi_api_key=self.api_key)
-
-    def build_tool(self) -> Tool:
-        wrapper = self._build_wrapper()
-
-        def search_func(
-            query: str, params: dict[str, Any] | None = None, max_results: int = 5, max_snippet_length: int = 100
-        ) -> list[dict[str, Any]]:
-            params = params or {}
-            full_results = wrapper.results(query=query, **params)
-            organic_results = full_results.get("organic_results", [])[:max_results]
-
-            limited_results = []
-            for result in organic_results:
-                limited_result = {
-                    "title": result.get("title", "")[:max_snippet_length],
-                    "link": result.get("link", ""),
-                    "snippet": result.get("snippet", "")[:max_snippet_length],
-                }
-                limited_results.append(limited_result)
-
-            return limited_results
-
-        tool = StructuredTool.from_function(
-            name="search_api",
-            description="Search for recent results using searchapi.io with result limiting",
-            func=search_func,
-            args_schema=self.SearchAPISchema,
-        )
-
-        self.status = f"Search API Tool created with engine: {self.engine}"
-        return tool
-
-    def run_model(self) -> list[Data]:
-        tool = self.build_tool()
-        results = tool.run(
-            {
-                "query": self.input_value,
-                "params": self.search_params or {},
-                "max_results": self.max_results,
-                "max_snippet_length": self.max_snippet_length,
-            }
-        )
-
-        data_list = [Data(data=result, text=result.get("snippet", "")) for result in results]
-
-        self.status = data_list
-        return data_list