lfx-nightly 0.2.0.dev25__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,143 @@
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.groq_constants import GROQ_MODELS
+from lfx.base.models.groq_model_discovery import get_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. Add your Groq API key to access additional available models.",
+            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]:
+        """Get available Groq models using the dynamic discovery system.
+
+        This method uses the groq_model_discovery module which:
+        - Fetches models directly from Groq API
+        - Automatically tests tool calling support
+        - Caches results for 24 hours
+        - Falls back to hardcoded list if API fails
+
+        Args:
+            tool_model_enabled: If True, only return models that support tool calling
+
+        Returns:
+            List of available model IDs
+        """
+        try:
+            # Get models with metadata from dynamic discovery system
+            api_key = self.api_key if hasattr(self, "api_key") and self.api_key else None
+            models_metadata = get_groq_models(api_key=api_key)
+
+            # Filter out non-LLM models (audio, TTS, guards)
+            model_ids = [
+                model_id for model_id, metadata in models_metadata.items() if not metadata.get("not_supported", False)
+            ]
+
+            # Filter by tool calling support if requested
+            if tool_model_enabled:
+                model_ids = [model_id for model_id in model_ids if models_metadata[model_id].get("tool_calling", False)]
+                logger.info(f"Loaded {len(model_ids)} Groq models with tool calling support")
+            else:
+                logger.info(f"Loaded {len(model_ids)} Groq models")
+        except (ValueError, KeyError, TypeError, ImportError) as e:
+            logger.exception(f"Error getting model names: {e}")
+            # Fallback to hardcoded list from groq_constants.py
+            return GROQ_MODELS
+        else:
+            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 (ValueError, KeyError, TypeError, ImportError) 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 (ValueError, KeyError, TypeError, AttributeError) 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,154 @@
+"""Helpers module - backwards compatibility for moved components."""
+
+from __future__ import annotations
+
+import sys
+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",
+]
+
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.helpers.current_date
+_redirected_submodules = {
+    "lfx.components.helpers.current_date": "lfx.components.utilities.current_date",
+    "lfx.components.helpers.calculator_core": "lfx.components.utilities.calculator_core",
+    "lfx.components.helpers.id_generator": "lfx.components.utilities.id_generator",
+    "lfx.components.helpers.memory": "lfx.components.models_and_agents.memory",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import helper components on attribute access."""
+    # Handle submodule access for backwards compatibility
+    # e.g., lfx.components.helpers.id_generator -> lfx.components.utilities.id_generator
+    if attr_name == "id_generator":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.id_generator")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "calculator_core":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.calculator_core")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "current_date":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.current_date")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "memory":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.memory")
+        globals()[attr_name] = result
+        return result
+
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+
+    # CurrentDateComponent, CalculatorComponent, and IDGeneratorComponent were moved to utilities
+    # Forward them to utilities for backwards compatibility
+    if attr_name in ("CurrentDateComponent", "CalculatorComponent", "IDGeneratorComponent"):
+        from lfx.components import utilities
+
+        result = getattr(utilities, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # MemoryComponent was moved to models_and_agents
+    # Forward it to models_and_agents for backwards compatibility
+    if attr_name == "MemoryComponent":
+        from lfx.components import models_and_agents
+
+        result = getattr(models_and_agents, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # CreateListComponent, MessageStoreComponent, and OutputParserComponent were moved to processing
+    # Forward them to processing for backwards compatibility
+    if attr_name == "CreateListComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, attr_name)
+        globals()[attr_name] = result
+        return result
+    if attr_name == "MessageStoreComponent":
+        from lfx.components import processing
+
+        result = processing.MessageStoreComponent
+        globals()[attr_name] = result
+        return result
+    if attr_name == "OutputParserComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    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/homeassistant/__init__.py

@@ -0,0 +1,7 @@
+from .home_assistant_control import HomeAssistantControl
+from .list_home_assistant_states import ListHomeAssistantStates
+
+__all__ = [
+    "HomeAssistantControl",
+    "ListHomeAssistantStates",
+]