langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/supabase/supabase.py

@@ -1,76 +0,0 @@
-from langchain_community.vectorstores import SupabaseVectorStore
-from supabase.client import Client, create_client
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.io import HandleInput, IntInput, SecretStrInput, StrInput
-from langflow.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 []

langflow/components/tavily/__init__.py

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

langflow/components/tavily/tavily_extract.py

@@ -1,117 +0,0 @@
-import httpx
-
-from langflow.custom import Component
-from langflow.io import BoolInput, DropdownInput, MessageTextInput, Output, SecretStrInput
-from langflow.logging.logger import logger
-from langflow.schema import Data
-from langflow.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)

langflow/components/tavily/tavily_search.py

@@ -1,212 +0,0 @@
-import httpx
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.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)

langflow/components/tools/__init__.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from typing import TYPE_CHECKING, Any
-
-from langchain_core._api.deprecation import LangChainDeprecationWarning
-
-from langflow.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__)

langflow/components/tools/calculator.py

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

langflow/components/tools/google_search_api.py

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