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

langflow/components/sambanova/sambanova.py

@@ -1,84 +0,0 @@
-from langchain_sambanova import ChatSambaNovaCloud
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.model import LCModelComponent
-from langflow.base.models.sambanova_constants import SAMBANOVA_MODEL_NAMES
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.io import DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
-
-
-class SambaNovaComponent(LCModelComponent):
-    display_name = "SambaNova"
-    description = "Generate text using Sambanova LLMs."
-    documentation = "https://cloud.sambanova.ai/"
-    icon = "SambaNova"
-    name = "SambaNovaModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        StrInput(
-            name="base_url",
-            display_name="SambaNova Cloud Base Url",
-            advanced=True,
-            info="The base URL of the Sambanova Cloud API. "
-            "Defaults to https://api.sambanova.ai/v1/chat/completions. "
-            "You can change this to use other urls like Sambastudio",
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            advanced=False,
-            options=SAMBANOVA_MODEL_NAMES,
-            value=SAMBANOVA_MODEL_NAMES[0],
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="Sambanova API Key",
-            info="The Sambanova API Key to use for the Sambanova model.",
-            advanced=False,
-            value="SAMBANOVA_API_KEY",
-            required=True,
-        ),
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            advanced=True,
-            value=2048,
-            info="The maximum number of tokens to generate.",
-        ),
-        SliderInput(
-            name="top_p",
-            display_name="top_p",
-            advanced=True,
-            value=1.0,
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            info="Model top_p",
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            range_spec=RangeSpec(min=0, max=2, step=0.01),
-            advanced=True,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        sambanova_url = self.base_url
-        sambanova_api_key = self.api_key
-        model_name = self.model_name
-        max_tokens = self.max_tokens
-        top_p = self.top_p
-        temperature = self.temperature
-
-        api_key = SecretStr(sambanova_api_key).get_secret_value() if sambanova_api_key else None
-
-        return ChatSambaNovaCloud(
-            model=model_name,
-            max_tokens=max_tokens or 1024,
-            temperature=temperature or 0.07,
-            top_p=top_p,
-            sambanova_url=sambanova_url,
-            sambanova_api_key=api_key,
-        )

langflow/components/scrapegraph/__init__.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .scrapegraph_markdownify_api import ScrapeGraphMarkdownifyApi
-    from .scrapegraph_search_api import ScrapeGraphSearchApi
-    from .scrapegraph_smart_scraper_api import ScrapeGraphSmartScraperApi
-
-_dynamic_imports = {
-    "ScrapeGraphMarkdownifyApi": "scrapegraph_markdownify_api",
-    "ScrapeGraphSearchApi": "scrapegraph_search_api",
-    "ScrapeGraphSmartScraperApi": "scrapegraph_smart_scraper_api",
-}
-
-__all__ = [
-    "ScrapeGraphMarkdownifyApi",
-    "ScrapeGraphSearchApi",
-    "ScrapeGraphSmartScraperApi",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import scrapegraph 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__)

langflow/components/scrapegraph/scrapegraph_markdownify_api.py

@@ -1,64 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import (
-    MessageTextInput,
-    Output,
-    SecretStrInput,
-)
-from langflow.schema.data import Data
-
-
-class ScrapeGraphMarkdownifyApi(Component):
-    display_name: str = "ScrapeGraph Markdownify API"
-    description: str = "Given a URL, it will return the markdownified content of the website."
-    name = "ScrapeGraphMarkdownifyApi"
-
-    output_types: list[str] = ["Document"]
-    documentation: str = "https://docs.scrapegraphai.com/services/markdownify"
-
-    inputs = [
-        SecretStrInput(
-            name="api_key",
-            display_name="ScrapeGraph API Key",
-            required=True,
-            password=True,
-            info="The API key to use ScrapeGraph API.",
-        ),
-        MessageTextInput(
-            name="url",
-            display_name="URL",
-            tool_mode=True,
-            info="The URL to markdownify.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data", name="data", method="scrape"),
-    ]
-
-    def scrape(self) -> list[Data]:
-        try:
-            from scrapegraph_py import Client
-            from scrapegraph_py.logger import sgai_logger
-        except ImportError as e:
-            msg = "Could not import scrapegraph-py package. Please install it with `pip install scrapegraph-py`."
-            raise ImportError(msg) from e
-
-        # Set logging level
-        sgai_logger.set_logging(level="INFO")
-
-        # Initialize the client with API key
-        sgai_client = Client(api_key=self.api_key)
-
-        try:
-            # Markdownify request
-            response = sgai_client.markdownify(
-                website_url=self.url,
-            )
-
-            # Close the client
-            sgai_client.close()
-
-            return Data(data=response)
-        except Exception:
-            sgai_client.close()
-            raise

langflow/components/scrapegraph/scrapegraph_search_api.py

@@ -1,64 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import (
-    MessageTextInput,
-    Output,
-    SecretStrInput,
-)
-from langflow.schema.data import Data
-
-
-class ScrapeGraphSearchApi(Component):
-    display_name: str = "ScrapeGraph Search API"
-    description: str = "Given a search prompt, it will return search results using ScrapeGraph's search functionality."
-    name = "ScrapeGraphSearchApi"
-
-    documentation: str = "https://docs.scrapegraphai.com/services/searchscraper"
-    icon = "ScrapeGraph"
-
-    inputs = [
-        SecretStrInput(
-            name="api_key",
-            display_name="ScrapeGraph API Key",
-            required=True,
-            password=True,
-            info="The API key to use ScrapeGraph API.",
-        ),
-        MessageTextInput(
-            name="user_prompt",
-            display_name="Search Prompt",
-            tool_mode=True,
-            info="The search prompt to use.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data", name="data", method="search"),
-    ]
-
-    def search(self) -> list[Data]:
-        try:
-            from scrapegraph_py import Client
-            from scrapegraph_py.logger import sgai_logger
-        except ImportError as e:
-            msg = "Could not import scrapegraph-py package. Please install it with `pip install scrapegraph-py`."
-            raise ImportError(msg) from e
-
-        # Set logging level
-        sgai_logger.set_logging(level="INFO")
-
-        # Initialize the client with API key
-        sgai_client = Client(api_key=self.api_key)
-
-        try:
-            # SearchScraper request
-            response = sgai_client.searchscraper(
-                user_prompt=self.user_prompt,
-            )
-
-            # Close the client
-            sgai_client.close()
-
-            return Data(data=response)
-        except Exception:
-            sgai_client.close()
-            raise

langflow/components/scrapegraph/scrapegraph_smart_scraper_api.py

@@ -1,71 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import (
-    MessageTextInput,
-    Output,
-    SecretStrInput,
-)
-from langflow.schema.data import Data
-
-
-class ScrapeGraphSmartScraperApi(Component):
-    display_name: str = "ScrapeGraph Smart Scraper API"
-    description: str = "Given a URL, it will return the structured data of the website."
-    name = "ScrapeGraphSmartScraperApi"
-
-    output_types: list[str] = ["Document"]
-    documentation: str = "https://docs.scrapegraphai.com/services/smartscraper"
-
-    inputs = [
-        SecretStrInput(
-            name="api_key",
-            display_name="ScrapeGraph API Key",
-            required=True,
-            password=True,
-            info="The API key to use ScrapeGraph API.",
-        ),
-        MessageTextInput(
-            name="url",
-            display_name="URL",
-            tool_mode=True,
-            info="The URL to scrape.",
-        ),
-        MessageTextInput(
-            name="prompt",
-            display_name="Prompt",
-            tool_mode=True,
-            info="The prompt to use for the smart scraper.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data", name="data", method="scrape"),
-    ]
-
-    def scrape(self) -> list[Data]:
-        try:
-            from scrapegraph_py import Client
-            from scrapegraph_py.logger import sgai_logger
-        except ImportError as e:
-            msg = "Could not import scrapegraph-py package. Please install it with `pip install scrapegraph-py`."
-            raise ImportError(msg) from e
-
-        # Set logging level
-        sgai_logger.set_logging(level="INFO")
-
-        # Initialize the client with API key
-        sgai_client = Client(api_key=self.api_key)
-
-        try:
-            # SmartScraper request
-            response = sgai_client.smartscraper(
-                website_url=self.url,
-                user_prompt=self.prompt,
-            )
-
-            # Close the client
-            sgai_client.close()
-
-            return Data(data=response)
-        except Exception:
-            sgai_client.close()
-            raise

langflow/components/searchapi/__init__.py

@@ -1,36 +0,0 @@
-"""SearchAPI components for LangFlow."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.searchapi.search import SearchComponent
-
-_dynamic_imports = {
-    "SearchComponent": "search",
-}
-
-__all__ = [
-    "SearchComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import searchapi 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__)

langflow/components/searchapi/search.py

@@ -1,79 +0,0 @@
-from typing import Any
-
-from langchain_community.utilities.searchapi import SearchApiAPIWrapper
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DictInput, DropdownInput, IntInput, MultilineInput, SecretStrInput
-from langflow.io import Output
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-
-
-class SearchComponent(Component):
-    display_name: str = "SearchApi"
-    description: str = "Calls the SearchApi API with result limiting. Supports Google, Bing and DuckDuckGo."
-    documentation: str = "https://www.searchapi.io/docs/google"
-    icon = "SearchAPI"
-
-    inputs = [
-        DropdownInput(name="engine", display_name="Engine", value="google", options=["google", "bing", "duckduckgo"]),
-        SecretStrInput(name="api_key", display_name="SearchAPI API Key", required=True),
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-            tool_mode=True,
-        ),
-        DictInput(name="search_params", display_name="Search 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="DataFrame", name="dataframe", method="fetch_content_dataframe"),
-    ]
-
-    def _build_wrapper(self):
-        return SearchApiAPIWrapper(engine=self.engine, searchapi_api_key=self.api_key)
-
-    def run_model(self) -> DataFrame:
-        return self.fetch_content_dataframe()
-
-    def fetch_content(self) -> list[Data]:
-        wrapper = self._build_wrapper()
-
-        def search_func(
-            query: str, params: dict[str, Any] | None = None, max_results: int = 5, max_snippet_length: int = 100
-        ) -> list[Data]:
-            params = params or {}
-            full_results = wrapper.results(query=query, **params)
-            organic_results = full_results.get("organic_results", [])[:max_results]
-
-            return [
-                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
-            ]
-
-        results = search_func(
-            self.input_value,
-            self.search_params or {},
-            self.max_results,
-            self.max_snippet_length,
-        )
-        self.status = results
-        return results
-
-    def fetch_content_dataframe(self) -> DataFrame:
-        """Convert the search results to a DataFrame.
-
-        Returns:
-            DataFrame: A DataFrame containing the search results.
-        """
-        data = self.fetch_content()
-        return DataFrame(data)

langflow/components/serpapi/__init__.py

@@ -1,3 +0,0 @@
-from .serp import SerpComponent
-
-__all__ = ["SerpComponent"]

langflow/components/serpapi/serp.py

@@ -1,115 +0,0 @@
-from typing import Any
-
-from langchain_community.utilities.serpapi import SerpAPIWrapper
-from langchain_core.tools import ToolException
-from pydantic import BaseModel, Field
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
-from langflow.io import Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.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)

langflow/components/serper/__init__.py

@@ -1,3 +0,0 @@
-from .google_serper_api_core import GoogleSerperAPICore
-
-__all__ = ["GoogleSerperAPICore"]

langflow/components/serper/google_serper_api_core.py

@@ -1,74 +0,0 @@
-from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import IntInput, MultilineInput, Output, SecretStrInput
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.message import Message
-
-
-class GoogleSerperAPICore(Component):
-    display_name = "Serper Google Search API"
-    description = "Calls the Serper.dev Google Search API and fetches the results."
-    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

langflow/components/supabase/__init__.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .supabase import SupabaseVectorStoreComponent
-    from .supabase_composio import SupabaseComposioComponent
-
-_dynamic_imports = {
-    "SupabaseVectorStoreComponent": "supabase",
-    "SupabaseComposioComponent": "supabase_composio",
-}
-
-__all__ = [
-    "SupabaseComposioComponent",
-    "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__)