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

lfx/components/serpapi/serp.py

@@ -0,0 +1,115 @@
+from typing import Any
+
+from langchain_community.utilities.serpapi import SerpAPIWrapper
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
+from lfx.io import Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+
+class SerpAPISchema(BaseModel):
+    """Schema for SerpAPI search parameters."""
+
+    query: str = Field(..., description="The search query")
+    params: dict[str, Any] | None = Field(
+        default={
+            "engine": "google",
+            "google_domain": "google.com",
+            "gl": "us",
+            "hl": "en",
+        },
+        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")
+
+
+class SerpComponent(Component):
+    display_name = "Serp Search API"
+    description = "Call Serp Search API with result limiting"
+    name = "Serp"
+    icon = "SerpSearch"
+
+    inputs = [
+        SecretStrInput(name="serpapi_api_key", display_name="SerpAPI API Key", required=True),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            tool_mode=True,
+        ),
+        DictInput(name="search_params", display_name="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),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="fetch_content"),
+        Output(display_name="Text", name="text", method="fetch_content_text"),
+    ]
+
+    def _build_wrapper(self, params: dict[str, Any] | None = None) -> SerpAPIWrapper:
+        """Build a SerpAPIWrapper with the provided parameters."""
+        params = params or {}
+        if params:
+            return SerpAPIWrapper(
+                serpapi_api_key=self.serpapi_api_key,
+                params=params,
+            )
+        return SerpAPIWrapper(serpapi_api_key=self.serpapi_api_key)
+
+    def run_model(self) -> list[Data]:
+        return self.fetch_content()
+
+    def fetch_content(self) -> list[Data]:
+        wrapper = self._build_wrapper(self.search_params)
+
+        def search_func(
+            query: str, params: dict[str, Any] | None = None, max_results: int = 5, max_snippet_length: int = 100
+        ) -> list[Data]:
+            try:
+                local_wrapper = wrapper
+                if params:
+                    local_wrapper = self._build_wrapper(params)
+
+                full_results = local_wrapper.results(query)
+                organic_results = full_results.get("organic_results", [])[:max_results]
+
+                limited_results = [
+                    Data(
+                        text=result.get("snippet", ""),
+                        data={
+                            "title": result.get("title", "")[:max_snippet_length],
+                            "link": result.get("link", ""),
+                            "snippet": result.get("snippet", "")[:max_snippet_length],
+                        },
+                    )
+                    for result in organic_results
+                ]
+
+            except Exception as e:
+                error_message = f"Error in SerpAPI search: {e!s}"
+                logger.debug(error_message)
+                raise ToolException(error_message) from e
+            return limited_results
+
+        results = search_func(
+            self.input_value,
+            params=self.search_params,
+            max_results=self.max_results,
+            max_snippet_length=self.max_snippet_length,
+        )
+        self.status = results
+        return results
+
+    def fetch_content_text(self) -> Message:
+        data = self.fetch_content()
+        result_string = ""
+        for item in data:
+            result_string += item.text + "\n"
+        self.status = result_string
+        return Message(text=result_string)

lfx/components/supabase/__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 .supabase import SupabaseVectorStoreComponent
+
+_dynamic_imports = {
+    "SupabaseVectorStoreComponent": "supabase",
+}
+
+__all__ = [
+    "SupabaseVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Supabase 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/supabase/supabase.py

@@ -0,0 +1,76 @@
+from langchain_community.vectorstores import SupabaseVectorStore
+from supabase.client import Client, create_client
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import HandleInput, IntInput, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class SupabaseVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Supabase"
+    description = "Supabase Vector Store with search capabilities"
+    name = "SupabaseVectorStore"
+    icon = "Supabase"
+
+    inputs = [
+        StrInput(name="supabase_url", display_name="Supabase URL", required=True),
+        SecretStrInput(name="supabase_service_key", display_name="Supabase Service Key", required=True),
+        StrInput(name="table_name", display_name="Table Name", advanced=True),
+        StrInput(name="query_name", display_name="Query Name"),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> SupabaseVectorStore:
+        supabase: Client = create_client(self.supabase_url, supabase_key=self.supabase_service_key)
+
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        if documents:
+            supabase_vs = SupabaseVectorStore.from_documents(
+                documents=documents,
+                embedding=self.embedding,
+                query_name=self.query_name,
+                client=supabase,
+                table_name=self.table_name,
+            )
+        else:
+            supabase_vs = SupabaseVectorStore(
+                client=supabase,
+                embedding=self.embedding,
+                table_name=self.table_name,
+                query_name=self.query_name,
+            )
+
+        return supabase_vs
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/tavily/__init__.py

@@ -0,0 +1,4 @@
+from .tavily_extract import TavilyExtractComponent
+from .tavily_search import TavilySearchComponent
+
+__all__ = ["TavilyExtractComponent", "TavilySearchComponent"]

lfx/components/tavily/tavily_extract.py

@@ -0,0 +1,117 @@
+import httpx
+
+from lfx.custom import Component
+from lfx.io import BoolInput, DropdownInput, MessageTextInput, Output, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class TavilyExtractComponent(Component):
+    """Separate component specifically for Tavily Extract functionality."""
+
+    display_name = "Tavily Extract API"
+    description = """**Tavily Extract** extract raw content from URLs."""
+    icon = "TavilyIcon"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="Tavily API Key",
+            required=True,
+            info="Your Tavily API Key.",
+        ),
+        MessageTextInput(
+            name="urls",
+            display_name="URLs",
+            info="Comma-separated list of URLs to extract content from.",
+            required=True,
+        ),
+        DropdownInput(
+            name="extract_depth",
+            display_name="Extract Depth",
+            info="The depth of the extraction process.",
+            options=["basic", "advanced"],
+            value="basic",
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_images",
+            display_name="Include Images",
+            info="Include a list of images extracted from the URLs.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content"),
+    ]
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def fetch_content(self) -> list[Data]:
+        """Fetches and processes extracted content into a list of Data objects."""
+        try:
+            # Split URLs by comma and clean them
+            urls = [url.strip() for url in (self.urls or "").split(",") if url.strip()]
+            if not urls:
+                error_message = "No valid URLs provided"
+                logger.error(error_message)
+                return [Data(text=error_message, data={"error": error_message})]
+
+            url = "https://api.tavily.com/extract"
+            headers = {
+                "content-type": "application/json",
+                "accept": "application/json",
+                "Authorization": f"Bearer {self.api_key}",
+            }
+            payload = {
+                "urls": urls,
+                "extract_depth": self.extract_depth,
+                "include_images": self.include_images,
+            }
+
+            with httpx.Client(timeout=90.0) as client:
+                response = client.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+
+        except httpx.TimeoutException as exc:
+            error_message = f"Request timed out (90s): {exc}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except httpx.HTTPStatusError as exc:
+            error_message = f"HTTP error occurred: {exc.response.status_code} - {exc.response.text}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except (ValueError, KeyError, AttributeError, httpx.RequestError) as exc:
+            error_message = f"Data processing error: {exc}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        else:
+            extract_results = response.json()
+            data_results = []
+
+            # Process successful extractions
+            for result in extract_results.get("results", []):
+                raw_content = result.get("raw_content", "")
+                images = result.get("images", [])
+                result_data = {"url": result.get("url"), "raw_content": raw_content, "images": images}
+                data_results.append(Data(text=raw_content, data=result_data))
+
+            # Process failed extractions
+            if extract_results.get("failed_results"):
+                data_results.append(
+                    Data(
+                        text="Failed extractions",
+                        data={"failed_results": extract_results["failed_results"]},
+                    )
+                )
+
+            self.status = data_results
+            return data_results
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/tavily/tavily_search.py

@@ -0,0 +1,212 @@
+import httpx
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+
+class TavilySearchComponent(Component):
+    display_name = "Tavily Search API"
+    description = """**Tavily Search** is a search engine optimized for LLMs and RAG, \
+        aimed at efficient, quick, and persistent search results."""
+    icon = "TavilyIcon"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="Tavily API Key",
+            required=True,
+            info="Your Tavily API Key.",
+        ),
+        MessageTextInput(
+            name="query",
+            display_name="Search Query",
+            info="The search query you want to execute with Tavily.",
+            tool_mode=True,
+        ),
+        DropdownInput(
+            name="search_depth",
+            display_name="Search Depth",
+            info="The depth of the search.",
+            options=["basic", "advanced"],
+            value="advanced",
+            advanced=True,
+        ),
+        IntInput(
+            name="chunks_per_source",
+            display_name="Chunks Per Source",
+            info=("The number of content chunks to retrieve from each source (1-3). Only works with advanced search."),
+            value=3,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="topic",
+            display_name="Search Topic",
+            info="The category of the search.",
+            options=["general", "news"],
+            value="general",
+            advanced=True,
+        ),
+        IntInput(
+            name="days",
+            display_name="Days",
+            info="Number of days back from current date to include. Only available with news topic.",
+            value=7,
+            advanced=True,
+        ),
+        IntInput(
+            name="max_results",
+            display_name="Max Results",
+            info="The maximum number of search results to return.",
+            value=5,
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_answer",
+            display_name="Include Answer",
+            info="Include a short answer to original query.",
+            value=True,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="time_range",
+            display_name="Time Range",
+            info="The time range back from the current date to filter results.",
+            options=["day", "week", "month", "year"],
+            value=None,  # Default to None to make it optional
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_images",
+            display_name="Include Images",
+            info="Include a list of query-related images in the response.",
+            value=True,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="include_domains",
+            display_name="Include Domains",
+            info="Comma-separated list of domains to include in the search results.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="exclude_domains",
+            display_name="Exclude Domains",
+            info="Comma-separated list of domains to exclude from the search results.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_raw_content",
+            display_name="Include Raw Content",
+            info="Include the cleaned and parsed HTML content of each search result.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def fetch_content(self) -> list[Data]:
+        try:
+            # Only process domains if they're provided
+            include_domains = None
+            exclude_domains = None
+
+            if self.include_domains:
+                include_domains = [domain.strip() for domain in self.include_domains.split(",") if domain.strip()]
+
+            if self.exclude_domains:
+                exclude_domains = [domain.strip() for domain in self.exclude_domains.split(",") if domain.strip()]
+
+            url = "https://api.tavily.com/search"
+            headers = {
+                "content-type": "application/json",
+                "accept": "application/json",
+            }
+
+            payload = {
+                "api_key": self.api_key,
+                "query": self.query,
+                "search_depth": self.search_depth,
+                "topic": self.topic,
+                "max_results": self.max_results,
+                "include_images": self.include_images,
+                "include_answer": self.include_answer,
+                "include_raw_content": self.include_raw_content,
+                "days": self.days,
+                "time_range": self.time_range,
+            }
+
+            # Only add domains to payload if they exist and have values
+            if include_domains:
+                payload["include_domains"] = include_domains
+            if exclude_domains:
+                payload["exclude_domains"] = exclude_domains
+
+            # Add conditional parameters only if they should be included
+            if self.search_depth == "advanced" and self.chunks_per_source:
+                payload["chunks_per_source"] = self.chunks_per_source
+
+            if self.topic == "news" and self.days:
+                payload["days"] = int(self.days)  # Ensure days is an integer
+
+            # Add time_range if it's set
+            if hasattr(self, "time_range") and self.time_range:
+                payload["time_range"] = self.time_range
+
+            # Add timeout handling
+            with httpx.Client(timeout=90.0) as client:
+                response = client.post(url, json=payload, headers=headers)
+
+            response.raise_for_status()
+            search_results = response.json()
+
+            data_results = []
+
+            if self.include_answer and search_results.get("answer"):
+                data_results.append(Data(text=search_results["answer"]))
+
+            for result in search_results.get("results", []):
+                content = result.get("content", "")
+                result_data = {
+                    "title": result.get("title"),
+                    "url": result.get("url"),
+                    "content": content,
+                    "score": result.get("score"),
+                }
+                if self.include_raw_content:
+                    result_data["raw_content"] = result.get("raw_content")
+
+                data_results.append(Data(text=content, data=result_data))
+
+            if self.include_images and search_results.get("images"):
+                data_results.append(Data(text="Images found", data={"images": search_results["images"]}))
+
+        except httpx.TimeoutException:
+            error_message = "Request timed out (90s). Please try again or adjust parameters."
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except httpx.HTTPStatusError as exc:
+            error_message = f"HTTP error occurred: {exc.response.status_code} - {exc.response.text}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except httpx.RequestError as exc:
+            error_message = f"Request error occurred: {exc}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except ValueError as exc:
+            error_message = f"Invalid response format: {exc}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        else:
+            self.status = data_results
+            return data_results
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/textsplitters/__init__.py

@@ -0,0 +1,3 @@
+"""LangFlow text splitters components."""
+
+__all__: list[str] = []

lfx/components/toolkits/__init__.py

@@ -0,0 +1,3 @@
+"""LangFlow toolkits components."""
+
+__all__: list[str] = []

lfx/components/tools/__init__.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING, Any
+
+from langchain_core._api.deprecation import LangChainDeprecationWarning
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .calculator import CalculatorToolComponent
+    from .google_search_api import GoogleSearchAPIComponent
+    from .google_serper_api import GoogleSerperAPIComponent
+    from .python_code_structured_tool import PythonCodeStructuredTool
+    from .python_repl import PythonREPLToolComponent
+    from .search_api import SearchAPIComponent
+    from .searxng import SearXNGToolComponent
+    from .serp_api import SerpAPIComponent
+    from .tavily_search_tool import TavilySearchToolComponent
+    from .wikidata_api import WikidataAPIComponent
+    from .wikipedia_api import WikipediaAPIComponent
+    from .yahoo_finance import YfinanceToolComponent
+
+_dynamic_imports = {
+    "CalculatorToolComponent": "calculator",
+    "GoogleSearchAPIComponent": "google_search_api",
+    "GoogleSerperAPIComponent": "google_serper_api",
+    "PythonCodeStructuredTool": "python_code_structured_tool",
+    "PythonREPLToolComponent": "python_repl",
+    "SearchAPIComponent": "search_api",
+    "SearXNGToolComponent": "searxng",
+    "SerpAPIComponent": "serp_api",
+    "TavilySearchToolComponent": "tavily_search_tool",
+    "WikidataAPIComponent": "wikidata_api",
+    "WikipediaAPIComponent": "wikipedia_api",
+    "YfinanceToolComponent": "yahoo_finance",
+}
+
+__all__ = [
+    "CalculatorToolComponent",
+    "GoogleSearchAPIComponent",
+    "GoogleSerperAPIComponent",
+    "PythonCodeStructuredTool",
+    "PythonREPLToolComponent",
+    "SearXNGToolComponent",
+    "SearchAPIComponent",
+    "SerpAPIComponent",
+    "TavilySearchToolComponent",
+    "WikidataAPIComponent",
+    "WikipediaAPIComponent",
+    "YfinanceToolComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import tool components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", LangChainDeprecationWarning)
+            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__)