lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/tools/calculator.py

@@ -0,0 +1,109 @@
+import ast
+import operator
+
+import pytest
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import MessageTextInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+
+class CalculatorToolComponent(LCToolComponent):
+    display_name = "Calculator"
+    description = "Perform basic arithmetic operations on a given expression."
+    icon = "calculator"
+    name = "CalculatorTool"
+    legacy = True
+    replacement = ["helpers.CalculatorComponent"]
+
+    inputs = [
+        MessageTextInput(
+            name="expression",
+            display_name="Expression",
+            info="The arithmetic expression to evaluate (e.g., '4*4*(33/22)+12-20').",
+        ),
+    ]
+
+    class CalculatorToolSchema(BaseModel):
+        expression: str = Field(..., description="The arithmetic expression to evaluate.")
+
+    def run_model(self) -> list[Data]:
+        return self._evaluate_expression(self.expression)
+
+    def build_tool(self) -> Tool:
+        try:
+            from langchain.tools import StructuredTool
+        except Exception:  # noqa: BLE001
+            pytest.skip("langchain is not available")
+
+        return StructuredTool.from_function(
+            name="calculator",
+            description="Evaluate basic arithmetic expressions. Input should be a string containing the expression.",
+            func=self._eval_expr_with_error,
+            args_schema=self.CalculatorToolSchema,
+        )
+
+    def _eval_expr(self, node):
+        if isinstance(node, ast.Num):
+            return node.n
+        if isinstance(node, ast.BinOp):
+            left_val = self._eval_expr(node.left)
+            right_val = self._eval_expr(node.right)
+            return self.operators[type(node.op)](left_val, right_val)
+        if isinstance(node, ast.UnaryOp):
+            operand_val = self._eval_expr(node.operand)
+            return self.operators[type(node.op)](operand_val)
+        if isinstance(node, ast.Call):
+            msg = (
+                "Function calls like sqrt(), sin(), cos() etc. are not supported. "
+                "Only basic arithmetic operations (+, -, *, /, **) are allowed."
+            )
+            raise TypeError(msg)
+        msg = f"Unsupported operation or expression type: {type(node).__name__}"
+        raise TypeError(msg)
+
+    def _eval_expr_with_error(self, expression: str) -> list[Data]:
+        try:
+            return self._evaluate_expression(expression)
+        except Exception as e:
+            raise ToolException(str(e)) from e
+
+    def _evaluate_expression(self, expression: str) -> list[Data]:
+        try:
+            # Parse the expression and evaluate it
+            tree = ast.parse(expression, mode="eval")
+            result = self._eval_expr(tree.body)
+
+            # Format the result to a reasonable number of decimal places
+            formatted_result = f"{result:.6f}".rstrip("0").rstrip(".")
+
+            self.status = formatted_result
+            return [Data(data={"result": formatted_result})]
+
+        except (SyntaxError, TypeError, KeyError) as e:
+            error_message = f"Invalid expression: {e}"
+            self.status = error_message
+            return [Data(data={"error": error_message, "input": expression})]
+        except ZeroDivisionError:
+            error_message = "Error: Division by zero"
+            self.status = error_message
+            return [Data(data={"error": error_message, "input": expression})]
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error evaluating expression", exc_info=True)
+            error_message = f"Error: {e}"
+            self.status = error_message
+            return [Data(data={"error": error_message, "input": expression})]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.operators = {
+            ast.Add: operator.add,
+            ast.Sub: operator.sub,
+            ast.Mult: operator.mul,
+            ast.Div: operator.truediv,
+            ast.Pow: operator.pow,
+        }

lfx/components/tools/google_search_api.py

@@ -0,0 +1,45 @@
+from langchain_core.tools import Tool
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.inputs.inputs import IntInput, MultilineInput, SecretStrInput
+from lfx.schema.data import Data
+
+
+class GoogleSearchAPIComponent(LCToolComponent):
+    display_name = "Google Search API [DEPRECATED]"
+    description = "Call Google Search API."
+    name = "GoogleSearchAPI"
+    icon = "Google"
+    legacy = True
+    inputs = [
+        SecretStrInput(name="google_api_key", display_name="Google API Key", required=True),
+        SecretStrInput(name="google_cse_id", display_name="Google CSE ID", required=True),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+        ),
+        IntInput(name="k", display_name="Number of results", value=4, required=True),
+    ]
+
+    def run_model(self) -> Data | list[Data]:
+        wrapper = self._build_wrapper()
+        results = wrapper.results(query=self.input_value, num_results=self.k)
+        data = [Data(data=result, text=result["snippet"]) for result in results]
+        self.status = data
+        return data
+
+    def build_tool(self) -> Tool:
+        wrapper = self._build_wrapper()
+        return Tool(
+            name="google_search",
+            description="Search Google for recent results.",
+            func=wrapper.run,
+        )
+
+    def _build_wrapper(self):
+        try:
+            from langchain_google_community import GoogleSearchAPIWrapper
+        except ImportError as e:
+            msg = "Please install langchain-google-community to use GoogleSearchAPIWrapper."
+            raise ImportError(msg) from e
+        return GoogleSearchAPIWrapper(google_api_key=self.google_api_key, google_cse_id=self.google_cse_id, k=self.k)

lfx/components/tools/google_serper_api.py

@@ -0,0 +1,115 @@
+from typing import Any
+
+from langchain.tools import StructuredTool
+from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import (
+    DictInput,
+    DropdownInput,
+    IntInput,
+    MultilineInput,
+    SecretStrInput,
+)
+from lfx.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)

lfx/components/tools/python_code_structured_tool.py

@@ -0,0 +1,328 @@
+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 lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.inputs.inputs import BoolInput, DropdownInput, FieldTypes, HandleInput, MessageTextInput, MultilineInput
+from lfx.io import Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.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
+    replacement = ["processing.PythonREPLComponent"]
+
+    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

lfx/components/tools/python_repl.py

@@ -0,0 +1,98 @@
+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 lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import StrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+
+class PythonREPLToolComponent(LCToolComponent):
+    display_name = "Python REPL"
+    description = "A tool for running Python code in a REPL environment."
+    name = "PythonREPLTool"
+    icon = "Python"
+    legacy = True
+    replacement = ["processing.PythonREPLComponent"]
+
+    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})]