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

langflow/components/data/web_search.py

@@ -1,112 +0,0 @@
-import re
-from urllib.parse import parse_qs, unquote, urlparse
-
-import pandas as pd
-import requests
-from bs4 import BeautifulSoup
-
-from langflow.custom import Component
-from langflow.io import IntInput, MessageTextInput, Output
-from langflow.schema import DataFrame
-from langflow.services.deps import get_settings_service
-
-
-class WebSearchComponent(Component):
-    display_name = "Web Search"
-    description = "Performs a basic DuckDuckGo search (HTML scraping). May be subject to rate limits."
-    documentation: str = "https://docs.langflow.org/components-data#web-search"
-    icon = "search"
-    name = "WebSearchNoAPI"
-
-    inputs = [
-        MessageTextInput(
-            name="query",
-            display_name="Search Query",
-            info="Keywords to search for.",
-            tool_mode=True,
-            required=True,
-        ),
-        IntInput(
-            name="timeout",
-            display_name="Timeout",
-            info="Timeout for the web search request.",
-            value=5,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [Output(name="results", display_name="Search Results", method="perform_search")]
-
-    def validate_url(self, string: str) -> bool:
-        url_regex = re.compile(
-            r"^(https?:\/\/)?" r"(www\.)?" r"([a-zA-Z0-9.-]+)" r"(\.[a-zA-Z]{2,})?" r"(:\d+)?" r"(\/[^\s]*)?$",
-            re.IGNORECASE,
-        )
-        return bool(url_regex.match(string))
-
-    def ensure_url(self, url: str) -> str:
-        if not url.startswith(("http://", "https://")):
-            url = "https://" + url
-        if not self.validate_url(url):
-            msg = f"Invalid URL: {url}"
-            raise ValueError(msg)
-        return url
-
-    def _sanitize_query(self, query: str) -> str:
-        """Sanitize search query."""
-        # Remove potentially dangerous characters
-        return re.sub(r'[<>"\']', "", query.strip())
-
-    def perform_search(self) -> DataFrame:
-        query = self._sanitize_query(self.query)
-        if not query:
-            msg = "Empty search query"
-            raise ValueError(msg)
-        headers = {"User-Agent": get_settings_service().settings.user_agent}
-        params = {"q": query, "kl": "us-en"}
-        url = "https://html.duckduckgo.com/html/"
-
-        try:
-            response = requests.get(url, params=params, headers=headers, timeout=self.timeout)
-            response.raise_for_status()
-        except requests.RequestException as e:
-            self.status = f"Failed request: {e!s}"
-            return DataFrame(pd.DataFrame([{"title": "Error", "link": "", "snippet": str(e), "content": ""}]))
-
-        if not response.text or "text/html" not in response.headers.get("content-type", "").lower():
-            self.status = "No results found"
-            return DataFrame(
-                pd.DataFrame([{"title": "Error", "link": "", "snippet": "No results found", "content": ""}])
-            )
-        soup = BeautifulSoup(response.text, "html.parser")
-        results = []
-
-        for result in soup.select("div.result"):
-            title_tag = result.select_one("a.result__a")
-            snippet_tag = result.select_one("a.result__snippet")
-            if title_tag:
-                raw_link = title_tag.get("href", "")
-                parsed = urlparse(raw_link)
-                uddg = parse_qs(parsed.query).get("uddg", [""])[0]
-                decoded_link = unquote(uddg) if uddg else raw_link
-
-                try:
-                    final_url = self.ensure_url(decoded_link)
-                    page = requests.get(final_url, headers=headers, timeout=self.timeout)
-                    page.raise_for_status()
-                    content = BeautifulSoup(page.text, "lxml").get_text(separator=" ", strip=True)
-                except requests.RequestException as e:
-                    final_url = decoded_link
-                    content = f"(Failed to fetch: {e!s}"
-
-                results.append(
-                    {
-                        "title": title_tag.get_text(strip=True),
-                        "link": final_url,
-                        "snippet": snippet_tag.get_text(strip=True) if snippet_tag else "",
-                        "content": content,
-                    }
-                )
-
-        df_results = pd.DataFrame(results)
-        return DataFrame(df_results)

langflow/components/data/webhook.py

@@ -1,56 +0,0 @@
-import json
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import MultilineInput, Output
-from langflow.schema.data import Data
-
-
-class WebhookComponent(Component):
-    display_name = "Webhook"
-    documentation: str = "https://docs.langflow.org/components-data#webhook"
-    name = "Webhook"
-    icon = "webhook"
-
-    inputs = [
-        MultilineInput(
-            name="data",
-            display_name="Payload",
-            info="Receives a payload from external systems via HTTP POST.",
-            advanced=True,
-        ),
-        MultilineInput(
-            name="curl",
-            display_name="cURL",
-            value="CURL_WEBHOOK",
-            advanced=True,
-            input_types=[],
-        ),
-        MultilineInput(
-            name="endpoint",
-            display_name="Endpoint",
-            value="BACKEND_URL",
-            advanced=False,
-            copy_field=True,
-            input_types=[],
-        ),
-    ]
-    outputs = [
-        Output(display_name="Data", name="output_data", method="build_data"),
-    ]
-
-    def build_data(self) -> Data:
-        message: str | Data = ""
-        if not self.data:
-            self.status = "No data provided."
-            return Data(data={})
-        try:
-            my_data = self.data.replace('"\n"', '"\\n"')
-            body = json.loads(my_data or "{}")
-        except json.JSONDecodeError:
-            body = {"payload": self.data}
-            message = f"Invalid JSON payload. Please check the format.\n\n{self.data}"
-        data = Data(data=body)
-        if not message:
-            message = data
-        self.status = message
-        return data

langflow/components/datastax/__init__.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .astra_assistant_manager import AstraAssistantManager
-    from .astra_db import AstraDBChatMemory
-    from .astra_vectorize import AstraVectorizeComponent
-    from .astradb_cql import AstraDBCQLToolComponent
-    from .astradb_tool import AstraDBToolComponent
-    from .astradb_vectorstore import AstraDBVectorStoreComponent
-    from .create_assistant import AssistantsCreateAssistant
-    from .create_thread import AssistantsCreateThread
-    from .dotenv import Dotenv
-    from .get_assistant import AssistantsGetAssistantName
-    from .getenvvar import GetEnvVar
-    from .list_assistants import AssistantsListAssistants
-    from .run import AssistantsRun
-
-_dynamic_imports = {
-    "AssistantsCreateAssistant": "create_assistant",
-    "AssistantsCreateThread": "create_thread",
-    "AssistantsGetAssistantName": "get_assistant",
-    "AssistantsListAssistants": "list_assistants",
-    "AssistantsRun": "run",
-    "AstraAssistantManager": "astra_assistant_manager",
-    "AstraDBCQLToolComponent": "astradb_cql",
-    "AstraDBChatMemory": "astra_db",
-    "AstraDBToolComponent": "astradb_tool",
-    "AstraDBVectorStoreComponent": "astradb_vectorstore",
-    "AstraVectorizeComponent": "astra_vectorize",
-    "Dotenv": "dotenv",
-    "GetEnvVar": "getenvvar",
-}
-
-__all__ = [
-    "AssistantsCreateAssistant",
-    "AssistantsCreateThread",
-    "AssistantsGetAssistantName",
-    "AssistantsListAssistants",
-    "AssistantsRun",
-    "AstraAssistantManager",
-    "AstraDBCQLToolComponent",
-    "AstraDBChatMemory",
-    "AstraDBToolComponent",
-    "AstraDBVectorStoreComponent",
-    "AstraVectorizeComponent",
-    "Dotenv",
-    "GetEnvVar",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import datastax 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/datastax/astra_assistant_manager.py

@@ -1,306 +0,0 @@
-import asyncio
-from asyncio import to_thread
-from typing import TYPE_CHECKING, Any, cast
-
-from astra_assistants.astra_assistants_manager import AssistantManager
-from langchain_core.agents import AgentFinish
-
-from langflow.base.agents.events import ExceptionWithMessageError, process_agent_events
-from langflow.base.astra_assistants.util import (
-    get_patched_openai_client,
-    litellm_model_names,
-    sync_upload,
-    wrap_base_tool_as_tool_interface,
-)
-from langflow.custom.custom_component.component_with_cache import ComponentWithCache
-from langflow.inputs.inputs import DropdownInput, FileInput, HandleInput, MultilineInput
-from langflow.logging.logger import logger
-from langflow.memory import delete_message
-from langflow.schema.content_block import ContentBlock
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-from langflow.utils.constants import MESSAGE_SENDER_AI
-
-if TYPE_CHECKING:
-    from langflow.schema.log import SendMessageFunctionType
-
-
-class AstraAssistantManager(ComponentWithCache):
-    display_name = "Astra Assistant Agent"
-    name = "Astra Assistant Agent"
-    description = "Manages Assistant Interactions"
-    icon = "AstraDB"
-
-    inputs = [
-        DropdownInput(
-            name="model_name",
-            display_name="Model",
-            advanced=False,
-            options=litellm_model_names,
-            value="gpt-4o-mini",
-        ),
-        MultilineInput(
-            name="instructions",
-            display_name="Agent Instructions",
-            info="Instructions for the assistant, think of these as the system prompt.",
-        ),
-        HandleInput(
-            name="input_tools",
-            display_name="Tools",
-            input_types=["Tool"],
-            is_list=True,
-            required=False,
-            info="These are the tools that the agent can use to help with tasks.",
-        ),
-        # DropdownInput(
-        #    display_name="Tools",
-        #    name="tool",
-        #    options=tool_names,
-        # ),
-        MultilineInput(
-            name="user_message", display_name="User Message", info="User message to pass to the run.", tool_mode=True
-        ),
-        FileInput(
-            name="file",
-            display_name="File(s) for retrieval",
-            list=True,
-            info="Files to be sent with the message.",
-            required=False,
-            show=True,
-            file_types=[
-                "txt",
-                "md",
-                "mdx",
-                "csv",
-                "json",
-                "yaml",
-                "yml",
-                "xml",
-                "html",
-                "htm",
-                "pdf",
-                "docx",
-                "py",
-                "sh",
-                "sql",
-                "js",
-                "ts",
-                "tsx",
-                "jpg",
-                "jpeg",
-                "png",
-                "bmp",
-                "image",
-                "zip",
-                "tar",
-                "tgz",
-                "bz2",
-                "gz",
-                "c",
-                "cpp",
-                "cs",
-                "css",
-                "go",
-                "java",
-                "php",
-                "rb",
-                "tex",
-                "doc",
-                "docx",
-                "ppt",
-                "pptx",
-                "xls",
-                "xlsx",
-                "jsonl",
-            ],
-        ),
-        MultilineInput(
-            name="input_thread_id",
-            display_name="Thread ID (optional)",
-            info="ID of the thread",
-            advanced=True,
-        ),
-        MultilineInput(
-            name="input_assistant_id",
-            display_name="Assistant ID (optional)",
-            info="ID of the assistant",
-            advanced=True,
-        ),
-        MultilineInput(
-            name="env_set",
-            display_name="Environment Set",
-            info="Dummy input to allow chaining with Dotenv Component.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Assistant Response", name="assistant_response", method="get_assistant_response"),
-        Output(display_name="Tool output", name="tool_output", method="get_tool_output", hidden=True),
-        Output(display_name="Thread Id", name="output_thread_id", method="get_thread_id", hidden=True),
-        Output(display_name="Assistant Id", name="output_assistant_id", method="get_assistant_id", hidden=True),
-        Output(display_name="Vector Store Id", name="output_vs_id", method="get_vs_id", hidden=True),
-    ]
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.lock = asyncio.Lock()
-        self.initialized: bool = False
-        self._assistant_response: Message = None  # type: ignore[assignment]
-        self._tool_output: Message = None  # type: ignore[assignment]
-        self._thread_id: Message = None  # type: ignore[assignment]
-        self._assistant_id: Message = None  # type: ignore[assignment]
-        self._vs_id: Message = None  # type: ignore[assignment]
-        self.client = get_patched_openai_client(self._shared_component_cache)
-        self.input_tools: list[Any]
-
-    async def get_assistant_response(self) -> Message:
-        await self.initialize()
-        self.status = self._assistant_response
-        return self._assistant_response
-
-    async def get_vs_id(self) -> Message:
-        await self.initialize()
-        self.status = self._vs_id
-        return self._vs_id
-
-    async def get_tool_output(self) -> Message:
-        await self.initialize()
-        self.status = self._tool_output
-        return self._tool_output
-
-    async def get_thread_id(self) -> Message:
-        await self.initialize()
-        self.status = self._thread_id
-        return self._thread_id
-
-    async def get_assistant_id(self) -> Message:
-        await self.initialize()
-        self.status = self._assistant_id
-        return self._assistant_id
-
-    async def initialize(self) -> None:
-        async with self.lock:
-            if not self.initialized:
-                await self.process_inputs()
-                self.initialized = True
-
-    async def process_inputs(self) -> None:
-        await logger.ainfo(f"env_set is {self.env_set}")
-        await logger.ainfo(self.input_tools)
-        tools = []
-        tool_obj = None
-        if self.input_tools is None:
-            self.input_tools = []
-        for tool in self.input_tools:
-            tool_obj = wrap_base_tool_as_tool_interface(tool)
-            tools.append(tool_obj)
-
-        assistant_id = None
-        thread_id = None
-        if self.input_assistant_id:
-            assistant_id = self.input_assistant_id
-        if self.input_thread_id:
-            thread_id = self.input_thread_id
-
-        if hasattr(self, "graph"):
-            session_id = self.graph.session_id
-        elif hasattr(self, "_session_id"):
-            session_id = self._session_id
-        else:
-            session_id = None
-
-        agent_message = Message(
-            sender=MESSAGE_SENDER_AI,
-            sender_name=self.display_name or "Astra Assistant",
-            properties={"icon": "Bot", "state": "partial"},
-            content_blocks=[ContentBlock(title="Assistant Steps", contents=[])],
-            session_id=session_id,
-        )
-
-        assistant_manager = AssistantManager(
-            instructions=self.instructions,
-            model=self.model_name,
-            name="managed_assistant",
-            tools=tools,
-            client=self.client,
-            thread_id=thread_id,
-            assistant_id=assistant_id,
-        )
-
-        if self.file:
-            file = await to_thread(sync_upload, self.file, assistant_manager.client)
-            vector_store = assistant_manager.client.beta.vector_stores.create(name="my_vs", file_ids=[file.id])
-            assistant_tools = assistant_manager.assistant.tools
-            assistant_tools += [{"type": "file_search"}]
-            assistant = assistant_manager.client.beta.assistants.update(
-                assistant_manager.assistant.id,
-                tools=assistant_tools,
-                tool_resources={"file_search": {"vector_store_ids": [vector_store.id]}},
-            )
-            assistant_manager.assistant = assistant
-
-        async def step_iterator():
-            # Initial event
-            yield {"event": "on_chain_start", "name": "AstraAssistant", "data": {"input": {"text": self.user_message}}}
-
-            content = self.user_message
-            result = await assistant_manager.run_thread(content=content, tool=tool_obj)
-
-            # Tool usage if present
-            if "output" in result and "arguments" in result:
-                yield {"event": "on_tool_start", "name": "tool", "data": {"input": {"text": str(result["arguments"])}}}
-                yield {"event": "on_tool_end", "name": "tool", "data": {"output": result["output"]}}
-
-            if "file_search" in result and result["file_search"] is not None:
-                yield {"event": "on_tool_start", "name": "tool", "data": {"input": {"text": self.user_message}}}
-                file_search_str = ""
-                for chunk in result["file_search"].to_dict().get("chunks", []):
-                    file_search_str += f"## Chunk ID: `{chunk['chunk_id']}`\n"
-                    file_search_str += f"**Content:**\n\n```\n{chunk['content']}\n```\n\n"
-                    if "score" in chunk:
-                        file_search_str += f"**Score:** {chunk['score']}\n\n"
-                    if "file_id" in chunk:
-                        file_search_str += f"**File ID:** `{chunk['file_id']}`\n\n"
-                    if "file_name" in chunk:
-                        file_search_str += f"**File Name:** `{chunk['file_name']}`\n\n"
-                    if "bytes" in chunk:
-                        file_search_str += f"**Bytes:** {chunk['bytes']}\n\n"
-                    if "search_string" in chunk:
-                        file_search_str += f"**Search String:** {chunk['search_string']}\n\n"
-                yield {"event": "on_tool_end", "name": "tool", "data": {"output": file_search_str}}
-
-            if "text" not in result:
-                msg = f"No text in result, {result}"
-                raise ValueError(msg)
-
-            self._assistant_response = Message(text=result["text"])
-            if "decision" in result:
-                self._tool_output = Message(text=str(result["decision"].is_complete))
-            else:
-                self._tool_output = Message(text=result["text"])
-            self._thread_id = Message(text=assistant_manager.thread.id)
-            self._assistant_id = Message(text=assistant_manager.assistant.id)
-
-            # Final event - format it like AgentFinish to match the expected format
-            yield {
-                "event": "on_chain_end",
-                "name": "AstraAssistant",
-                "data": {"output": AgentFinish(return_values={"output": result["text"]}, log="")},
-            }
-
-        try:
-            if hasattr(self, "send_message"):
-                processed_result = await process_agent_events(
-                    step_iterator(),
-                    agent_message,
-                    cast("SendMessageFunctionType", self.send_message),
-                )
-                self.status = processed_result
-        except ExceptionWithMessageError as e:
-            msg_id = e.agent_message.id
-            await delete_message(id_=msg_id)
-            await self._send_message_event(e.agent_message, category="remove_message")
-            raise
-        except Exception:
-            raise

langflow/components/datastax/astra_db.py

@@ -1,69 +0,0 @@
-import os
-
-from astrapy.admin import parse_api_endpoint
-
-from langflow.base.memory.model import LCChatMemoryComponent
-from langflow.field_typing.constants import Memory
-from langflow.inputs.inputs import MessageTextInput, SecretStrInput, StrInput
-
-
-class AstraDBChatMemory(LCChatMemoryComponent):
-    display_name = "Astra DB Chat Memory"
-    description = "Retrieves and store chat messages from Astra DB."
-    name = "AstraDBChatMemory"
-    icon: str = "AstraDB"
-
-    inputs = [
-        SecretStrInput(
-            name="token",
-            display_name="Astra DB Application Token",
-            info="Authentication token for accessing Astra DB.",
-            value="ASTRA_DB_APPLICATION_TOKEN",
-            required=True,
-            advanced=os.getenv("ASTRA_ENHANCED", "false").lower() == "true",
-        ),
-        SecretStrInput(
-            name="api_endpoint",
-            display_name="API Endpoint",
-            info="API endpoint URL for the Astra DB service.",
-            value="ASTRA_DB_API_ENDPOINT",
-            required=True,
-        ),
-        StrInput(
-            name="collection_name",
-            display_name="Collection Name",
-            info="The name of the collection within Astra DB where the vectors will be stored.",
-            required=True,
-        ),
-        StrInput(
-            name="namespace",
-            display_name="Namespace",
-            info="Optional namespace within Astra DB to use for the collection.",
-            advanced=True,
-        ),
-        MessageTextInput(
-            name="session_id",
-            display_name="Session ID",
-            info="The session ID of the chat. If empty, the current session ID parameter will be used.",
-            advanced=True,
-        ),
-    ]
-
-    def build_message_history(self) -> Memory:
-        try:
-            from langchain_astradb.chat_message_histories import AstraDBChatMessageHistory
-        except ImportError as e:
-            msg = (
-                "Could not import langchain Astra DB integration package. "
-                "Please install it with `pip install langchain-astradb`."
-            )
-            raise ImportError(msg) from e
-
-        return AstraDBChatMessageHistory(
-            session_id=self.session_id,
-            collection_name=self.collection_name,
-            token=self.token,
-            api_endpoint=self.api_endpoint,
-            namespace=self.namespace or None,
-            environment=parse_api_endpoint(self.api_endpoint).environment,
-        )