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

lfx/components/tools/tavily_search_tool.py

@@ -0,0 +1,345 @@
+from enum import Enum
+
+import httpx
+from langchain.tools import StructuredTool
+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 BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+# Add at the top with other constants
+MAX_CHUNKS_PER_SOURCE = 3
+
+
+class TavilySearchDepth(Enum):
+    BASIC = "basic"
+    ADVANCED = "advanced"
+
+
+class TavilySearchTopic(Enum):
+    GENERAL = "general"
+    NEWS = "news"
+
+
+class TavilySearchTimeRange(Enum):
+    DAY = "day"
+    WEEK = "week"
+    MONTH = "month"
+    YEAR = "year"
+
+
+class TavilySearchSchema(BaseModel):
+    query: str = Field(..., description="The search query you want to execute with Tavily.")
+    search_depth: TavilySearchDepth = Field(TavilySearchDepth.BASIC, description="The depth of the search.")
+    topic: TavilySearchTopic = Field(TavilySearchTopic.GENERAL, description="The category of the search.")
+    max_results: int = Field(5, description="The maximum number of search results to return.")
+    include_images: bool = Field(default=False, description="Include a list of query-related images in the response.")
+    include_answer: bool = Field(default=False, description="Include a short answer to original query.")
+    chunks_per_source: int = Field(
+        default=MAX_CHUNKS_PER_SOURCE,
+        description=(
+            "The number of content chunks to retrieve from each source (max 500 chars each). Only for advanced search."
+        ),
+        ge=1,
+        le=MAX_CHUNKS_PER_SOURCE,
+    )
+    include_domains: list[str] = Field(
+        default=[],
+        description="A list of domains to specifically include in the search results.",
+    )
+    exclude_domains: list[str] = Field(
+        default=[],
+        description="A list of domains to specifically exclude from the search results.",
+    )
+    include_raw_content: bool = Field(
+        default=False,
+        description="Include the cleaned and parsed HTML content of each search result.",
+    )
+    days: int = Field(
+        default=7,
+        description="Number of days back from the current date to include. Only available if topic is news.",
+        ge=1,
+    )
+    time_range: TavilySearchTimeRange | None = Field(
+        default=None,
+        description="The time range back from the current date to filter results.",
+    )
+
+
+class TavilySearchToolComponent(LCToolComponent):
+    display_name = "Tavily Search API"
+    description = """**Tavily Search API** is a search engine optimized for LLMs and RAG, \
+        aimed at efficient, quick, and persistent search results. It can be used independently or as an agent tool.
+
+Note: Check 'Advanced' for all options.
+"""
+    icon = "TavilyIcon"
+    name = "TavilyAISearch"
+    documentation = "https://docs.tavily.com/"
+    legacy = True
+    replacement = ["tavily.TavilySearchComponent"]
+
+    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.",
+        ),
+        DropdownInput(
+            name="search_depth",
+            display_name="Search Depth",
+            info="The depth of the search.",
+            options=list(TavilySearchDepth),
+            value=TavilySearchDepth.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=MAX_CHUNKS_PER_SOURCE,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="topic",
+            display_name="Search Topic",
+            info="The category of the search.",
+            options=list(TavilySearchTopic),
+            value=TavilySearchTopic.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=list(TavilySearchTimeRange),
+            value=None,
+            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,
+        ),
+    ]
+
+    def run_model(self) -> list[Data]:
+        # Convert string values to enum instances with validation
+        try:
+            search_depth_enum = (
+                self.search_depth
+                if isinstance(self.search_depth, TavilySearchDepth)
+                else TavilySearchDepth(str(self.search_depth).lower())
+            )
+        except ValueError as e:
+            error_message = f"Invalid search depth value: {e!s}"
+            self.status = error_message
+            return [Data(data={"error": error_message})]
+
+        try:
+            topic_enum = (
+                self.topic if isinstance(self.topic, TavilySearchTopic) else TavilySearchTopic(str(self.topic).lower())
+            )
+        except ValueError as e:
+            error_message = f"Invalid topic value: {e!s}"
+            self.status = error_message
+            return [Data(data={"error": error_message})]
+
+        try:
+            time_range_enum = (
+                self.time_range
+                if isinstance(self.time_range, TavilySearchTimeRange)
+                else TavilySearchTimeRange(str(self.time_range).lower())
+                if self.time_range
+                else None
+            )
+        except ValueError as e:
+            error_message = f"Invalid time range value: {e!s}"
+            self.status = error_message
+            return [Data(data={"error": error_message})]
+
+        # Initialize domain variables as None
+        include_domains = None
+        exclude_domains = None
+
+        # Only process domains if they're provided
+        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()]
+
+        return self._tavily_search(
+            self.query,
+            search_depth=search_depth_enum,
+            topic=topic_enum,
+            max_results=self.max_results,
+            include_images=self.include_images,
+            include_answer=self.include_answer,
+            chunks_per_source=self.chunks_per_source,
+            include_domains=include_domains,
+            exclude_domains=exclude_domains,
+            include_raw_content=self.include_raw_content,
+            days=self.days,
+            time_range=time_range_enum,
+        )
+
+    def build_tool(self) -> Tool:
+        return StructuredTool.from_function(
+            name="tavily_search",
+            description="Perform a web search using the Tavily API.",
+            func=self._tavily_search,
+            args_schema=TavilySearchSchema,
+        )
+
+    def _tavily_search(
+        self,
+        query: str,
+        *,
+        search_depth: TavilySearchDepth = TavilySearchDepth.BASIC,
+        topic: TavilySearchTopic = TavilySearchTopic.GENERAL,
+        max_results: int = 5,
+        include_images: bool = False,
+        include_answer: bool = False,
+        chunks_per_source: int = MAX_CHUNKS_PER_SOURCE,
+        include_domains: list[str] | None = None,
+        exclude_domains: list[str] | None = None,
+        include_raw_content: bool = False,
+        days: int = 7,
+        time_range: TavilySearchTimeRange | None = None,
+    ) -> list[Data]:
+        # Validate enum values
+        if not isinstance(search_depth, TavilySearchDepth):
+            msg = f"Invalid search_depth value: {search_depth}"
+            raise TypeError(msg)
+        if not isinstance(topic, TavilySearchTopic):
+            msg = f"Invalid topic value: {topic}"
+            raise TypeError(msg)
+
+        # Validate chunks_per_source range
+        if not 1 <= chunks_per_source <= MAX_CHUNKS_PER_SOURCE:
+            msg = f"chunks_per_source must be between 1 and {MAX_CHUNKS_PER_SOURCE}, got {chunks_per_source}"
+            raise ValueError(msg)
+
+        # Validate days is positive
+        if days < 1:
+            msg = f"days must be greater than or equal to 1, got {days}"
+            raise ValueError(msg)
+
+        try:
+            url = "https://api.tavily.com/search"
+            headers = {
+                "content-type": "application/json",
+                "accept": "application/json",
+            }
+            payload = {
+                "api_key": self.api_key,
+                "query": query,
+                "search_depth": search_depth.value,
+                "topic": topic.value,
+                "max_results": max_results,
+                "include_images": include_images,
+                "include_answer": include_answer,
+                "chunks_per_source": chunks_per_source if search_depth == TavilySearchDepth.ADVANCED else None,
+                "include_domains": include_domains if include_domains else None,
+                "exclude_domains": exclude_domains if exclude_domains else None,
+                "include_raw_content": include_raw_content,
+                "days": days if topic == TavilySearchTopic.NEWS else None,
+                "time_range": time_range.value if time_range else None,
+            }
+
+            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 = [
+                Data(
+                    data={
+                        "title": result.get("title"),
+                        "url": result.get("url"),
+                        "content": result.get("content"),
+                        "score": result.get("score"),
+                        "raw_content": result.get("raw_content") if include_raw_content else None,
+                    }
+                )
+                for result in search_results.get("results", [])
+            ]
+
+            if include_answer and search_results.get("answer"):
+                data_results.insert(0, Data(data={"answer": search_results["answer"]}))
+
+            if include_images and search_results.get("images"):
+                data_results.append(Data(data={"images": search_results["images"]}))
+
+            self.status = data_results  # type: ignore[assignment]
+
+        except httpx.TimeoutException as e:
+            error_message = "Request timed out (90s). Please try again or adjust parameters."
+            logger.error(f"Timeout error: {e}")
+            self.status = error_message
+            raise ToolException(error_message) from e
+        except httpx.HTTPStatusError as e:
+            error_message = f"HTTP error: {e.response.status_code} - {e.response.text}"
+            logger.debug(error_message)
+            self.status = error_message
+            raise ToolException(error_message) from e
+        except Exception as e:
+            error_message = f"Unexpected error: {e}"
+            logger.debug("Error running Tavily Search", exc_info=True)
+            self.status = error_message
+            raise ToolException(error_message) from e
+        return data_results

lfx/components/tools/wikidata_api.py

@@ -0,0 +1,103 @@
+from typing import Any
+
+import httpx
+from langchain_core.tools import StructuredTool, 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 MultilineInput
+from lfx.schema.data import Data
+
+
+class WikidataSearchSchema(BaseModel):
+    query: str = Field(..., description="The search query for Wikidata")
+
+
+class WikidataAPIWrapper(BaseModel):
+    """Wrapper around Wikidata API."""
+
+    wikidata_api_url: str = "https://www.wikidata.org/w/api.php"
+
+    def results(self, query: str) -> list[dict[str, Any]]:
+        # Define request parameters for Wikidata API
+        params = {
+            "action": "wbsearchentities",
+            "format": "json",
+            "search": query,
+            "language": "en",
+        }
+
+        # Send request to Wikidata API
+        response = httpx.get(self.wikidata_api_url, params=params)
+        response.raise_for_status()
+        response_json = response.json()
+
+        # Extract and return search results
+        return response_json.get("search", [])
+
+    def run(self, query: str) -> list[dict[str, Any]]:
+        try:
+            results = self.results(query)
+            if results:
+                return results
+
+            error_message = "No search results found for the given query."
+
+            raise ToolException(error_message)
+
+        except Exception as e:
+            error_message = f"Error in Wikidata Search API: {e!s}"
+
+            raise ToolException(error_message) from e
+
+
+class WikidataAPIComponent(LCToolComponent):
+    display_name = "Wikidata API"
+    description = "Performs a search using the Wikidata API."
+    name = "WikidataAPI"
+    icon = "Wikipedia"
+    legacy = True
+    replacement = ["wikipedia.WikidataComponent"]
+
+    inputs = [
+        MultilineInput(
+            name="query",
+            display_name="Query",
+            info="The text query for similarity search on Wikidata.",
+            required=True,
+        ),
+    ]
+
+    def build_tool(self) -> Tool:
+        wrapper = WikidataAPIWrapper()
+
+        # Define the tool using StructuredTool and wrapper's run method
+        tool = StructuredTool.from_function(
+            name="wikidata_search_api",
+            description="Perform similarity search on Wikidata API",
+            func=wrapper.run,
+            args_schema=WikidataSearchSchema,
+        )
+
+        self.status = "Wikidata Search API Tool for Langchain"
+
+        return tool
+
+    def run_model(self) -> list[Data]:
+        tool = self.build_tool()
+
+        results = tool.run({"query": self.query})
+
+        # Transform the API response into Data objects
+        data = [
+            Data(
+                text=result["label"],
+                metadata=result,
+            )
+            for result in results
+        ]
+
+        self.status = data  # type: ignore[assignment]
+
+        return data

lfx/components/tools/wikipedia_api.py

@@ -0,0 +1,50 @@
+from typing import cast
+
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import BoolInput, IntInput, MessageTextInput, MultilineInput
+from lfx.schema.data import Data
+
+
+class WikipediaAPIComponent(LCToolComponent):
+    display_name = "Wikipedia API"
+    description = "Call Wikipedia API."
+    name = "WikipediaAPI"
+    icon = "Wikipedia"
+    legacy = True
+    replacement = ["wikipedia.WikipediaComponent"]
+
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+        ),
+        MessageTextInput(name="lang", display_name="Language", value="en"),
+        IntInput(name="k", display_name="Number of results", value=4, required=True),
+        BoolInput(name="load_all_available_meta", display_name="Load all available meta", value=False, advanced=True),
+        IntInput(
+            name="doc_content_chars_max", display_name="Document content characters max", value=4000, advanced=True
+        ),
+    ]
+
+    def run_model(self) -> list[Data]:
+        wrapper = self._build_wrapper()
+        docs = wrapper.load(self.input_value)
+        data = [Data.from_document(doc) for doc in docs]
+        self.status = data
+        return data
+
+    def build_tool(self) -> Tool:
+        wrapper = self._build_wrapper()
+        return cast("Tool", WikipediaQueryRun(api_wrapper=wrapper))
+
+    def _build_wrapper(self) -> WikipediaAPIWrapper:
+        return WikipediaAPIWrapper(
+            top_k_results=self.k,
+            lang=self.lang,
+            load_all_available_meta=self.load_all_available_meta,
+            doc_content_chars_max=self.doc_content_chars_max,
+        )

lfx/components/tools/yahoo_finance.py

@@ -0,0 +1,130 @@
+import ast
+import pprint
+from enum import Enum
+
+from langchain.tools import StructuredTool
+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 DropdownInput, IntInput, MessageTextInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+
+class YahooFinanceMethod(Enum):
+    GET_INFO = "get_info"
+    GET_NEWS = "get_news"
+    GET_ACTIONS = "get_actions"
+    GET_ANALYSIS = "get_analysis"
+    GET_BALANCE_SHEET = "get_balance_sheet"
+    GET_CALENDAR = "get_calendar"
+    GET_CASHFLOW = "get_cashflow"
+    GET_INSTITUTIONAL_HOLDERS = "get_institutional_holders"
+    GET_RECOMMENDATIONS = "get_recommendations"
+    GET_SUSTAINABILITY = "get_sustainability"
+    GET_MAJOR_HOLDERS = "get_major_holders"
+    GET_MUTUALFUND_HOLDERS = "get_mutualfund_holders"
+    GET_INSIDER_PURCHASES = "get_insider_purchases"
+    GET_INSIDER_TRANSACTIONS = "get_insider_transactions"
+    GET_INSIDER_ROSTER_HOLDERS = "get_insider_roster_holders"
+    GET_DIVIDENDS = "get_dividends"
+    GET_CAPITAL_GAINS = "get_capital_gains"
+    GET_SPLITS = "get_splits"
+    GET_SHARES = "get_shares"
+    GET_FAST_INFO = "get_fast_info"
+    GET_SEC_FILINGS = "get_sec_filings"
+    GET_RECOMMENDATIONS_SUMMARY = "get_recommendations_summary"
+    GET_UPGRADES_DOWNGRADES = "get_upgrades_downgrades"
+    GET_EARNINGS = "get_earnings"
+    GET_INCOME_STMT = "get_income_stmt"
+
+
+class YahooFinanceSchema(BaseModel):
+    symbol: str = Field(..., description="The stock symbol to retrieve data for.")
+    method: YahooFinanceMethod = Field(YahooFinanceMethod.GET_INFO, description="The type of data to retrieve.")
+    num_news: int | None = Field(5, description="The number of news articles to retrieve.")
+
+
+class YfinanceToolComponent(LCToolComponent):
+    display_name = "Yahoo! Finance"
+    description = """Uses [yfinance](https://pypi.org/project/yfinance/) (unofficial package) \
+to access financial data and market information from Yahoo! Finance."""
+    icon = "trending-up"
+    name = "YahooFinanceTool"
+    legacy = True
+    replacement = ["yahoosearch.YfinanceComponent"]
+
+    inputs = [
+        MessageTextInput(
+            name="symbol",
+            display_name="Stock Symbol",
+            info="The stock symbol to retrieve data for (e.g., AAPL, GOOG).",
+        ),
+        DropdownInput(
+            name="method",
+            display_name="Data Method",
+            info="The type of data to retrieve.",
+            options=list(YahooFinanceMethod),
+            value="get_news",
+        ),
+        IntInput(
+            name="num_news",
+            display_name="Number of News",
+            info="The number of news articles to retrieve (only applicable for get_news).",
+            value=5,
+        ),
+    ]
+
+    def run_model(self) -> list[Data]:
+        return self._yahoo_finance_tool(
+            self.symbol,
+            self.method,
+            self.num_news,
+        )
+
+    def build_tool(self) -> Tool:
+        return StructuredTool.from_function(
+            name="yahoo_finance",
+            description="Access financial data and market information from Yahoo! Finance.",
+            func=self._yahoo_finance_tool,
+            args_schema=YahooFinanceSchema,
+        )
+
+    def _yahoo_finance_tool(
+        self,
+        symbol: str,
+        method: YahooFinanceMethod,
+        num_news: int | None = 5,
+    ) -> list[Data]:
+        try:
+            import yfinance as yf
+        except ImportError as e:
+            msg = ""
+            raise ImportError(msg) from e
+
+        ticker = yf.Ticker(symbol)
+
+        try:
+            if method == YahooFinanceMethod.GET_INFO:
+                result = ticker.info
+            elif method == YahooFinanceMethod.GET_NEWS:
+                result = ticker.news[:num_news]
+            else:
+                result = getattr(ticker, method.value)()
+
+            result = pprint.pformat(result)
+
+            if method == YahooFinanceMethod.GET_NEWS:
+                data_list = [Data(data=article) for article in ast.literal_eval(result)]
+            else:
+                data_list = [Data(data={"result": result})]
+
+        except Exception as e:
+            error_message = f"Error retrieving data: {e}"
+            logger.debug(error_message)
+            self.status = error_message
+            raise ToolException(error_message) from e
+
+        return data_list

lfx/components/twelvelabs/__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 .convert_astra_results import ConvertAstraToTwelveLabs
+    from .pegasus_index import PegasusIndexVideo
+    from .split_video import SplitVideoComponent
+    from .text_embeddings import TwelveLabsTextEmbeddingsComponent
+    from .twelvelabs_pegasus import TwelveLabsPegasus
+    from .video_embeddings import TwelveLabsVideoEmbeddingsComponent
+    from .video_file import VideoFileComponent
+
+_dynamic_imports = {
+    "ConvertAstraToTwelveLabs": "convert_astra_results",
+    "PegasusIndexVideo": "pegasus_index",
+    "SplitVideoComponent": "split_video",
+    "TwelveLabsPegasus": "twelvelabs_pegasus",
+    "TwelveLabsTextEmbeddingsComponent": "text_embeddings",
+    "TwelveLabsVideoEmbeddingsComponent": "video_embeddings",
+    "VideoFileComponent": "video_file",
+}
+
+__all__ = [
+    "ConvertAstraToTwelveLabs",
+    "PegasusIndexVideo",
+    "SplitVideoComponent",
+    "TwelveLabsPegasus",
+    "TwelveLabsTextEmbeddingsComponent",
+    "TwelveLabsVideoEmbeddingsComponent",
+    "VideoFileComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import twelvelabs 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__)