lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/google/google_oauth_token.py

@@ -0,0 +1,89 @@
+import json
+import re
+from pathlib import Path
+
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import FileInput, MultilineInput, Output
+from lfx.schema.data import Data
+
+
+class GoogleOAuthToken(Component):
+    display_name = "Google OAuth Token"
+    description = "Generates a JSON string with your Google OAuth token."
+    documentation: str = "https://developers.google.com/identity/protocols/oauth2/web-server?hl=pt-br#python_1"
+    icon = "Google"
+    name = "GoogleOAuthToken"
+    legacy: bool = True
+    inputs = [
+        MultilineInput(
+            name="scopes",
+            display_name="Scopes",
+            info="Input scopes for your application.",
+            required=True,
+        ),
+        FileInput(
+            name="oauth_credentials",
+            display_name="Credentials File",
+            info="Input OAuth Credentials file (e.g. credentials.json).",
+            file_types=["json"],
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Output", name="output", method="build_output"),
+    ]
+
+    def validate_scopes(self, scopes):
+        pattern = (
+            r"^(https://www\.googleapis\.com/auth/[\w\.\-]+"
+            r"|mail\.google\.com/"
+            r"|www\.google\.com/calendar/feeds"
+            r"|www\.google\.com/m8/feeds)"
+            r"(,\s*https://www\.googleapis\.com/auth/[\w\.\-]+"
+            r"|mail\.google\.com/"
+            r"|www\.google\.com/calendar/feeds"
+            r"|www\.google\.com/m8/feeds)*$"
+        )
+        if not re.match(pattern, scopes):
+            error_message = "Invalid scope format."
+            raise ValueError(error_message)
+
+    def build_output(self) -> Data:
+        self.validate_scopes(self.scopes)
+
+        user_scopes = [scope.strip() for scope in self.scopes.split(",")]
+        if self.scopes:
+            scopes = user_scopes
+        else:
+            error_message = "Incorrect scope, check the scopes field."
+            raise ValueError(error_message)
+
+        creds = None
+        token_path = Path("token.json")
+
+        if token_path.exists():
+            creds = Credentials.from_authorized_user_file(str(token_path), scopes)
+
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                if self.oauth_credentials:
+                    client_secret_file = self.oauth_credentials
+                else:
+                    error_message = "OAuth 2.0 Credentials file not provided."
+                    raise ValueError(error_message)
+
+                flow = InstalledAppFlow.from_client_secrets_file(client_secret_file, scopes)
+                creds = flow.run_local_server(port=0)
+
+                token_path.write_text(creds.to_json(), encoding="utf-8")
+
+        creds_json = json.loads(creds.to_json())
+
+        return Data(data=creds_json)

lfx/components/google/google_search_api_core.py

@@ -0,0 +1,68 @@
+from langchain_google_community import GoogleSearchAPIWrapper
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import IntInput, MultilineInput, Output, SecretStrInput
+from lfx.schema.dataframe import DataFrame
+
+
+class GoogleSearchAPICore(Component):
+    display_name = "Google Search API"
+    description = "Call Google Search API and return results as a DataFrame."
+    icon = "Google"
+
+    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",
+            tool_mode=True,
+        ),
+        IntInput(
+            name="k",
+            display_name="Number of results",
+            value=4,
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Results",
+            name="results",
+            type_=DataFrame,
+            method="search_google",
+        ),
+    ]
+
+    def search_google(self) -> DataFrame:
+        """Search Google using the provided query."""
+        if not self.google_api_key:
+            return DataFrame([{"error": "Invalid Google API Key"}])
+
+        if not self.google_cse_id:
+            return DataFrame([{"error": "Invalid Google CSE ID"}])
+
+        try:
+            wrapper = GoogleSearchAPIWrapper(
+                google_api_key=self.google_api_key, google_cse_id=self.google_cse_id, k=self.k
+            )
+            results = wrapper.results(query=self.input_value, num_results=self.k)
+            return DataFrame(results)
+        except (ValueError, KeyError) as e:
+            return DataFrame([{"error": f"Invalid configuration: {e!s}"}])
+        except ConnectionError as e:
+            return DataFrame([{"error": f"Connection error: {e!s}"}])
+        except RuntimeError as e:
+            return DataFrame([{"error": f"Error occurred while searching: {e!s}"}])
+
+    def build(self):
+        return self.search_google

lfx/components/google/google_serper_api_core.py

@@ -0,0 +1,74 @@
+from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import IntInput, MultilineInput, Output, SecretStrInput
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+
+
+class GoogleSerperAPICore(Component):
+    display_name = "Google Serper API"
+    description = "Call the Serper.dev Google Search API."
+    icon = "Serper"
+
+    inputs = [
+        SecretStrInput(
+            name="serper_api_key",
+            display_name="Serper API Key",
+            required=True,
+        ),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            tool_mode=True,
+        ),
+        IntInput(
+            name="k",
+            display_name="Number of results",
+            value=4,
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Results",
+            name="results",
+            type_=DataFrame,
+            method="search_serper",
+        ),
+    ]
+
+    def search_serper(self) -> DataFrame:
+        try:
+            wrapper = self._build_wrapper()
+            results = wrapper.results(query=self.input_value)
+            list_results = results.get("organic", [])
+
+            # Convert results to DataFrame using list comprehension
+            df_data = [
+                {
+                    "title": result.get("title", ""),
+                    "link": result.get("link", ""),
+                    "snippet": result.get("snippet", ""),
+                }
+                for result in list_results
+            ]
+
+            return DataFrame(df_data)
+        except (ValueError, KeyError, ConnectionError) as e:
+            error_message = f"Error occurred while searching: {e!s}"
+            self.status = error_message
+            # Return DataFrame with error as a list of dictionaries
+            return DataFrame([{"error": error_message}])
+
+    def text_search_serper(self) -> Message:
+        search_results = self.search_serper()
+        text_result = search_results.to_string(index=False) if not search_results.empty else "No results found."
+        return Message(text=text_result)
+
+    def _build_wrapper(self):
+        return GoogleSerperAPIWrapper(serper_api_key=self.serper_api_key, k=self.k)
+
+    def build(self):
+        return self.search_serper

lfx/components/groq/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .groq import GroqModel
+
+_dynamic_imports = {
+    "GroqModel": "groq",
+}
+
+__all__ = [
+    "GroqModel",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import groq components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/groq/groq.py

@@ -0,0 +1,136 @@
+import requests
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.groq_constants import GROQ_MODELS, TOOL_CALLING_UNSUPPORTED_GROQ_MODELS, UNSUPPORTED_GROQ_MODELS
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput, SliderInput
+from lfx.log.logger import logger
+
+
+class GroqModel(LCModelComponent):
+    display_name: str = "Groq"
+    description: str = "Generate text using Groq."
+    icon = "Groq"
+    name = "GroqModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        SecretStrInput(
+            name="api_key", display_name="Groq API Key", info="API key for the Groq API.", real_time_refresh=True
+        ),
+        MessageTextInput(
+            name="base_url",
+            display_name="Groq API Base",
+            info="Base URL path for API requests, leave blank if not using a proxy or service emulator.",
+            advanced=True,
+            value="https://api.groq.com",
+            real_time_refresh=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Output Tokens",
+            info="The maximum number of tokens to generate.",
+            advanced=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            info="Run inference with this temperature. Must by in the closed interval [0.0, 1.0].",
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            advanced=True,
+        ),
+        IntInput(
+            name="n",
+            display_name="N",
+            info="Number of chat completions to generate for each prompt. "
+            "Note that the API may not return the full n completions if duplicates are generated.",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model",
+            info="The name of the model to use.",
+            options=GROQ_MODELS,
+            value=GROQ_MODELS[0],
+            refresh_button=True,
+            combobox=True,
+        ),
+        BoolInput(
+            name="tool_model_enabled",
+            display_name="Enable Tool Models",
+            info=(
+                "Select if you want to use models that can work with tools. If yes, only those models will be shown."
+            ),
+            advanced=False,
+            value=False,
+            real_time_refresh=True,
+        ),
+    ]
+
+    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
+        try:
+            url = f"{self.base_url}/openai/v1/models"
+            headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            model_list = response.json()
+            model_ids = [
+                model["id"] for model in model_list.get("data", []) if model["id"] not in UNSUPPORTED_GROQ_MODELS
+            ]
+        except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+            logger.exception(f"Error getting model names: {e}")
+            model_ids = GROQ_MODELS
+        if tool_model_enabled:
+            try:
+                from langchain_groq import ChatGroq
+            except ImportError as e:
+                msg = "langchain_groq is not installed. Please install it with `pip install langchain_groq`."
+                raise ImportError(msg) from e
+            for model in model_ids:
+                model_with_tool = ChatGroq(
+                    model=model,
+                    api_key=self.api_key,
+                    base_url=self.base_url,
+                )
+                if not self.supports_tool_calling(model_with_tool) or model in TOOL_CALLING_UNSUPPORTED_GROQ_MODELS:
+                    model_ids.remove(model)
+            return model_ids
+        return model_ids
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
+            try:
+                if len(self.api_key) != 0:
+                    try:
+                        ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
+                    except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+                        logger.exception(f"Error getting model names: {e}")
+                        ids = GROQ_MODELS
+                    build_config.setdefault("model_name", {})
+                    build_config["model_name"]["options"] = ids
+                    build_config["model_name"].setdefault("value", ids[0])
+            except Exception as e:
+                msg = f"Error getting model names: {e}"
+                raise ValueError(msg) from e
+        return build_config
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            from langchain_groq import ChatGroq
+        except ImportError as e:
+            msg = "langchain-groq is not installed. Please install it with `pip install langchain-groq`."
+            raise ImportError(msg) from e
+
+        return ChatGroq(
+            model=self.model_name,
+            max_tokens=self.max_tokens or None,
+            temperature=self.temperature,
+            base_url=self.base_url,
+            n=self.n or 1,
+            api_key=SecretStr(self.api_key).get_secret_value(),
+            streaming=self.stream,
+        )

lfx/components/helpers/__init__.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.helpers.calculator_core import CalculatorComponent
+    from lfx.components.helpers.create_list import CreateListComponent
+    from lfx.components.helpers.current_date import CurrentDateComponent
+    from lfx.components.helpers.id_generator import IDGeneratorComponent
+    from lfx.components.helpers.memory import MemoryComponent
+    from lfx.components.helpers.output_parser import OutputParserComponent
+    from lfx.components.helpers.store_message import MessageStoreComponent
+
+_dynamic_imports = {
+    "CalculatorComponent": "calculator_core",
+    "CreateListComponent": "create_list",
+    "CurrentDateComponent": "current_date",
+    "IDGeneratorComponent": "id_generator",
+    "MemoryComponent": "memory",
+    "OutputParserComponent": "output_parser",
+    "MessageStoreComponent": "store_message",
+}
+
+__all__ = [
+    "CalculatorComponent",
+    "CreateListComponent",
+    "CurrentDateComponent",
+    "IDGeneratorComponent",
+    "MemoryComponent",
+    "MessageStoreComponent",
+    "OutputParserComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import helper components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/helpers/calculator_core.py

@@ -0,0 +1,89 @@
+import ast
+import operator
+from collections.abc import Callable
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import MessageTextInput
+from lfx.io import Output
+from lfx.schema.data import Data
+
+
+class CalculatorComponent(Component):
+    display_name = "Calculator"
+    description = "Perform basic arithmetic operations on a given expression."
+    documentation: str = "https://docs.langflow.org/components-helpers#calculator"
+    icon = "calculator"
+
+    # Cache operators dictionary as a class variable
+    OPERATORS: dict[type[ast.operator], Callable] = {
+        ast.Add: operator.add,
+        ast.Sub: operator.sub,
+        ast.Mult: operator.mul,
+        ast.Div: operator.truediv,
+        ast.Pow: operator.pow,
+    }
+
+    inputs = [
+        MessageTextInput(
+            name="expression",
+            display_name="Expression",
+            info="The arithmetic expression to evaluate (e.g., '4*4*(33/22)+12-20').",
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="result", type_=Data, method="evaluate_expression"),
+    ]
+
+    def _eval_expr(self, node: ast.AST) -> float:
+        """Evaluate an AST node recursively."""
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, int | float):
+                return float(node.value)
+            error_msg = f"Unsupported constant type: {type(node.value).__name__}"
+            raise TypeError(error_msg)
+        if isinstance(node, ast.Num):  # For backwards compatibility
+            if isinstance(node.n, int | float):
+                return float(node.n)
+            error_msg = f"Unsupported number type: {type(node.n).__name__}"
+            raise TypeError(error_msg)
+
+        if isinstance(node, ast.BinOp):
+            op_type = type(node.op)
+            if op_type not in self.OPERATORS:
+                error_msg = f"Unsupported binary operator: {op_type.__name__}"
+                raise TypeError(error_msg)
+
+            left = self._eval_expr(node.left)
+            right = self._eval_expr(node.right)
+            return self.OPERATORS[op_type](left, right)
+
+        error_msg = f"Unsupported operation or expression type: {type(node).__name__}"
+        raise TypeError(error_msg)
+
+    def evaluate_expression(self) -> Data:
+        """Evaluate the mathematical expression and return the result."""
+        try:
+            tree = ast.parse(self.expression, mode="eval")
+            result = self._eval_expr(tree.body)
+
+            formatted_result = f"{float(result):.6f}".rstrip("0").rstrip(".")
+            self.log(f"Calculation result: {formatted_result}")
+
+            self.status = formatted_result
+            return Data(data={"result": formatted_result})
+
+        except ZeroDivisionError:
+            error_message = "Error: Division by zero"
+            self.status = error_message
+            return Data(data={"error": error_message, "input": self.expression})
+
+        except (SyntaxError, TypeError, KeyError, ValueError, AttributeError, OverflowError) as e:
+            error_message = f"Invalid expression: {e!s}"
+            self.status = error_message
+            return Data(data={"error": error_message, "input": self.expression})
+
+    def build(self):
+        """Return the main evaluation function."""
+        return self.evaluate_expression

lfx/components/helpers/create_list.py

@@ -0,0 +1,40 @@
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import StrInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+
+class CreateListComponent(Component):
+    display_name = "Create List"
+    description = "Creates a list of texts."
+    icon = "list"
+    name = "CreateList"
+    legacy = True
+
+    inputs = [
+        StrInput(
+            name="texts",
+            display_name="Texts",
+            info="Enter one or more texts.",
+            is_list=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data List", name="list", method="create_list"),
+        Output(display_name="DataFrame", name="dataframe", method="as_dataframe"),
+    ]
+
+    def create_list(self) -> list[Data]:
+        data = [Data(text=text) for text in self.texts]
+        self.status = data
+        return data
+
+    def as_dataframe(self) -> DataFrame:
+        """Convert the list of Data objects into a DataFrame.
+
+        Returns:
+            DataFrame: A DataFrame containing the list data.
+        """
+        return DataFrame(self.create_list())

lfx/components/helpers/current_date.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo, available_timezones
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DropdownInput, Output
+from lfx.log.logger import logger
+from lfx.schema.message import Message
+
+
+class CurrentDateComponent(Component):
+    display_name = "Current Date"
+    description = "Returns the current date and time in the selected timezone."
+    documentation: str = "https://docs.langflow.org/components-helpers#current-date"
+    icon = "clock"
+    name = "CurrentDate"
+
+    inputs = [
+        DropdownInput(
+            name="timezone",
+            display_name="Timezone",
+            options=list(available_timezones()),
+            value="UTC",
+            info="Select the timezone for the current date and time.",
+            tool_mode=True,
+        ),
+    ]
+    outputs = [
+        Output(display_name="Current Date", name="current_date", method="get_current_date"),
+    ]
+
+    def get_current_date(self) -> Message:
+        try:
+            tz = ZoneInfo(self.timezone)
+            current_date = datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S %Z")
+            result = f"Current date and time in {self.timezone}: {current_date}"
+            self.status = result
+            return Message(text=result)
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error getting current date", exc_info=True)
+            error_message = f"Error: {e}"
+            self.status = error_message
+            return Message(text=error_message)

lfx/components/helpers/id_generator.py

@@ -0,0 +1,42 @@
+import uuid
+from typing import Any
+
+from typing_extensions import override
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output
+from lfx.schema.dotdict import dotdict
+from lfx.schema.message import Message
+
+
+class IDGeneratorComponent(Component):
+    display_name = "ID Generator"
+    description = "Generates a unique ID."
+    icon = "fingerprint"
+    name = "IDGenerator"
+    legacy = True
+
+    inputs = [
+        MessageTextInput(
+            name="unique_id",
+            display_name="Value",
+            info="The generated unique ID.",
+            refresh_button=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="ID", name="id", method="generate_id"),
+    ]
+
+    @override
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        if field_name == "unique_id":
+            build_config[field_name]["value"] = str(uuid.uuid4())
+        return build_config
+
+    def generate_id(self) -> Message:
+        unique_id = self.unique_id or str(uuid.uuid4())
+        self.status = f"Generated ID: {unique_id}"
+        return Message(text=unique_id)