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

langflow/components/groq/groq.py

@@ -1,140 +0,0 @@
-import requests
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.groq_constants import (
-    GROQ_MODELS,
-    TOOL_CALLING_UNSUPPORTED_GROQ_MODELS,
-    UNSUPPORTED_GROQ_MODELS,
-)
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.io import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput, SliderInput
-from langflow.logging.logger import logger
-
-
-class GroqModel(LCModelComponent):
-    display_name: str = "Groq"
-    description: str = "Generate text using Groq."
-    icon = "Groq"
-    name = "GroqModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        SecretStrInput(
-            name="api_key", display_name="Groq API Key", info="API key for the Groq API.", real_time_refresh=True
-        ),
-        MessageTextInput(
-            name="base_url",
-            display_name="Groq API Base",
-            info="Base URL path for API requests, leave blank if not using a proxy or service emulator.",
-            advanced=True,
-            value="https://api.groq.com",
-            real_time_refresh=True,
-        ),
-        IntInput(
-            name="max_tokens",
-            display_name="Max Output Tokens",
-            info="The maximum number of tokens to generate.",
-            advanced=True,
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            info="Run inference with this temperature. Must by in the closed interval [0.0, 1.0].",
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            advanced=True,
-        ),
-        IntInput(
-            name="n",
-            display_name="N",
-            info="Number of chat completions to generate for each prompt. "
-            "Note that the API may not return the full n completions if duplicates are generated.",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model",
-            info="The name of the model to use.",
-            options=GROQ_MODELS,
-            value=GROQ_MODELS[0],
-            refresh_button=True,
-            combobox=True,
-        ),
-        BoolInput(
-            name="tool_model_enabled",
-            display_name="Enable Tool Models",
-            info=(
-                "Select if you want to use models that can work with tools. If yes, only those models will be shown."
-            ),
-            advanced=False,
-            value=False,
-            real_time_refresh=True,
-        ),
-    ]
-
-    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
-        try:
-            url = f"{self.base_url}/openai/v1/models"
-            headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
-
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            model_list = response.json()
-            model_ids = [
-                model["id"] for model in model_list.get("data", []) if model["id"] not in UNSUPPORTED_GROQ_MODELS
-            ]
-        except (ImportError, ValueError, requests.exceptions.RequestException) as e:
-            logger.exception(f"Error getting model names: {e}")
-            model_ids = GROQ_MODELS
-        if tool_model_enabled:
-            try:
-                from langchain_groq import ChatGroq
-            except ImportError as e:
-                msg = "langchain_groq is not installed. Please install it with `pip install langchain_groq`."
-                raise ImportError(msg) from e
-            for model in model_ids:
-                model_with_tool = ChatGroq(
-                    model=model,
-                    api_key=self.api_key,
-                    base_url=self.base_url,
-                )
-                if not self.supports_tool_calling(model_with_tool) or model in TOOL_CALLING_UNSUPPORTED_GROQ_MODELS:
-                    model_ids.remove(model)
-            return model_ids
-        return model_ids
-
-    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
-        if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
-            try:
-                if len(self.api_key) != 0:
-                    try:
-                        ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
-                    except (ImportError, ValueError, requests.exceptions.RequestException) as e:
-                        logger.exception(f"Error getting model names: {e}")
-                        ids = GROQ_MODELS
-                    build_config.setdefault("model_name", {})
-                    build_config["model_name"]["options"] = ids
-                    build_config["model_name"].setdefault("value", ids[0])
-            except Exception as e:
-                msg = f"Error getting model names: {e}"
-                raise ValueError(msg) from e
-        return build_config
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        try:
-            from langchain_groq import ChatGroq
-        except ImportError as e:
-            msg = "langchain-groq is not installed. Please install it with `pip install langchain-groq`."
-            raise ImportError(msg) from e
-
-        return ChatGroq(
-            model=self.model_name,
-            max_tokens=self.max_tokens or None,
-            temperature=self.temperature,
-            base_url=self.base_url,
-            n=self.n or 1,
-            api_key=SecretStr(self.api_key).get_secret_value(),
-            streaming=self.stream,
-        )

langflow/components/helpers/__init__.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.helpers.calculator_core import CalculatorComponent
-    from langflow.components.helpers.create_list import CreateListComponent
-    from langflow.components.helpers.current_date import CurrentDateComponent
-    from langflow.components.helpers.id_generator import IDGeneratorComponent
-    from langflow.components.helpers.memory import MemoryComponent
-    from langflow.components.helpers.output_parser import OutputParserComponent
-    from langflow.components.helpers.store_message import MessageStoreComponent
-
-_dynamic_imports = {
-    "CalculatorComponent": "calculator_core",
-    "CreateListComponent": "create_list",
-    "CurrentDateComponent": "current_date",
-    "IDGeneratorComponent": "id_generator",
-    "MemoryComponent": "memory",
-    "OutputParserComponent": "output_parser",
-    "MessageStoreComponent": "store_message",
-}
-
-__all__ = [
-    "CalculatorComponent",
-    "CreateListComponent",
-    "CurrentDateComponent",
-    "IDGeneratorComponent",
-    "MemoryComponent",
-    "MessageStoreComponent",
-    "OutputParserComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import helper 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/helpers/calculator_core.py

@@ -1,89 +0,0 @@
-import ast
-import operator
-from collections.abc import Callable
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import MessageTextInput
-from langflow.io import Output
-from langflow.schema.data import Data
-
-
-class CalculatorComponent(Component):
-    display_name = "Calculator"
-    description = "Perform basic arithmetic operations on a given expression."
-    documentation: str = "https://docs.langflow.org/components-helpers#calculator"
-    icon = "calculator"
-
-    # Cache operators dictionary as a class variable
-    OPERATORS: dict[type[ast.operator], Callable] = {
-        ast.Add: operator.add,
-        ast.Sub: operator.sub,
-        ast.Mult: operator.mul,
-        ast.Div: operator.truediv,
-        ast.Pow: operator.pow,
-    }
-
-    inputs = [
-        MessageTextInput(
-            name="expression",
-            display_name="Expression",
-            info="The arithmetic expression to evaluate (e.g., '4*4*(33/22)+12-20').",
-            tool_mode=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data", name="result", type_=Data, method="evaluate_expression"),
-    ]
-
-    def _eval_expr(self, node: ast.AST) -> float:
-        """Evaluate an AST node recursively."""
-        if isinstance(node, ast.Constant):
-            if isinstance(node.value, int | float):
-                return float(node.value)
-            error_msg = f"Unsupported constant type: {type(node.value).__name__}"
-            raise TypeError(error_msg)
-        if isinstance(node, ast.Num):  # For backwards compatibility
-            if isinstance(node.n, int | float):
-                return float(node.n)
-            error_msg = f"Unsupported number type: {type(node.n).__name__}"
-            raise TypeError(error_msg)
-
-        if isinstance(node, ast.BinOp):
-            op_type = type(node.op)
-            if op_type not in self.OPERATORS:
-                error_msg = f"Unsupported binary operator: {op_type.__name__}"
-                raise TypeError(error_msg)
-
-            left = self._eval_expr(node.left)
-            right = self._eval_expr(node.right)
-            return self.OPERATORS[op_type](left, right)
-
-        error_msg = f"Unsupported operation or expression type: {type(node).__name__}"
-        raise TypeError(error_msg)
-
-    def evaluate_expression(self) -> Data:
-        """Evaluate the mathematical expression and return the result."""
-        try:
-            tree = ast.parse(self.expression, mode="eval")
-            result = self._eval_expr(tree.body)
-
-            formatted_result = f"{float(result):.6f}".rstrip("0").rstrip(".")
-            self.log(f"Calculation result: {formatted_result}")
-
-            self.status = formatted_result
-            return Data(data={"result": formatted_result})
-
-        except ZeroDivisionError:
-            error_message = "Error: Division by zero"
-            self.status = error_message
-            return Data(data={"error": error_message, "input": self.expression})
-
-        except (SyntaxError, TypeError, KeyError, ValueError, AttributeError, OverflowError) as e:
-            error_message = f"Invalid expression: {e!s}"
-            self.status = error_message
-            return Data(data={"error": error_message, "input": self.expression})
-
-    def build(self):
-        """Return the main evaluation function."""
-        return self.evaluate_expression

langflow/components/helpers/create_list.py

@@ -1,40 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import StrInput
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-
-class CreateListComponent(Component):
-    display_name = "Create List"
-    description = "Creates a list of texts."
-    icon = "list"
-    name = "CreateList"
-    legacy = True
-
-    inputs = [
-        StrInput(
-            name="texts",
-            display_name="Texts",
-            info="Enter one or more texts.",
-            is_list=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data List", name="list", method="create_list"),
-        Output(display_name="DataFrame", name="dataframe", method="as_dataframe"),
-    ]
-
-    def create_list(self) -> list[Data]:
-        data = [Data(text=text) for text in self.texts]
-        self.status = data
-        return data
-
-    def as_dataframe(self) -> DataFrame:
-        """Convert the list of Data objects into a DataFrame.
-
-        Returns:
-            DataFrame: A DataFrame containing the list data.
-        """
-        return DataFrame(self.create_list())

langflow/components/helpers/current_date.py

@@ -1,42 +0,0 @@
-from datetime import datetime
-from zoneinfo import ZoneInfo, available_timezones
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import DropdownInput, Output
-from langflow.logging.logger import logger
-from langflow.schema.message import Message
-
-
-class CurrentDateComponent(Component):
-    display_name = "Current Date"
-    description = "Returns the current date and time in the selected timezone."
-    documentation: str = "https://docs.langflow.org/components-helpers#current-date"
-    icon = "clock"
-    name = "CurrentDate"
-
-    inputs = [
-        DropdownInput(
-            name="timezone",
-            display_name="Timezone",
-            options=list(available_timezones()),
-            value="UTC",
-            info="Select the timezone for the current date and time.",
-            tool_mode=True,
-        ),
-    ]
-    outputs = [
-        Output(display_name="Current Date", name="current_date", method="get_current_date"),
-    ]
-
-    def get_current_date(self) -> Message:
-        try:
-            tz = ZoneInfo(self.timezone)
-            current_date = datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S %Z")
-            result = f"Current date and time in {self.timezone}: {current_date}"
-            self.status = result
-            return Message(text=result)
-        except Exception as e:  # noqa: BLE001
-            logger.debug("Error getting current date", exc_info=True)
-            error_message = f"Error: {e}"
-            self.status = error_message
-            return Message(text=error_message)

langflow/components/helpers/id_generator.py

@@ -1,42 +0,0 @@
-import uuid
-from typing import Any
-
-from typing_extensions import override
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output
-from langflow.schema.dotdict import dotdict
-from langflow.schema.message import Message
-
-
-class IDGeneratorComponent(Component):
-    display_name = "ID Generator"
-    description = "Generates a unique ID."
-    icon = "fingerprint"
-    name = "IDGenerator"
-    legacy = True
-
-    inputs = [
-        MessageTextInput(
-            name="unique_id",
-            display_name="Value",
-            info="The generated unique ID.",
-            refresh_button=True,
-            tool_mode=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="ID", name="id", method="generate_id"),
-    ]
-
-    @override
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name == "unique_id":
-            build_config[field_name]["value"] = str(uuid.uuid4())
-        return build_config
-
-    def generate_id(self) -> Message:
-        unique_id = self.unique_id or str(uuid.uuid4())
-        self.status = f"Generated ID: {unique_id}"
-        return Message(text=unique_id)

langflow/components/helpers/memory.py

@@ -1,251 +0,0 @@
-from typing import Any, cast
-
-from langflow.custom.custom_component.component import Component
-from langflow.helpers.data import data_to_text
-from langflow.inputs.inputs import DropdownInput, HandleInput, IntInput, MessageTextInput, MultilineInput, TabInput
-from langflow.memory import aget_messages, astore_message
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.dotdict import dotdict
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-from langflow.utils.component_utils import set_current_fields, set_field_display
-from langflow.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI, MESSAGE_SENDER_USER
-
-
-class MemoryComponent(Component):
-    display_name = "Message History"
-    description = "Stores or retrieves stored chat messages from Langflow tables or an external memory."
-    documentation: str = "https://docs.langflow.org/components-helpers#message-history"
-    icon = "message-square-more"
-    name = "Memory"
-    default_keys = ["mode", "memory"]
-    mode_config = {
-        "Store": ["message", "memory", "sender", "sender_name", "session_id"],
-        "Retrieve": ["n_messages", "order", "template", "memory"],
-    }
-
-    inputs = [
-        TabInput(
-            name="mode",
-            display_name="Mode",
-            options=["Retrieve", "Store"],
-            value="Retrieve",
-            info="Operation mode: Store messages or Retrieve messages.",
-            real_time_refresh=True,
-        ),
-        MessageTextInput(
-            name="message",
-            display_name="Message",
-            info="The chat message to be stored.",
-            tool_mode=True,
-            dynamic=True,
-            show=False,
-        ),
-        HandleInput(
-            name="memory",
-            display_name="External Memory",
-            input_types=["Memory"],
-            info="Retrieve messages from an external memory. If empty, it will use the Langflow tables.",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="sender_type",
-            display_name="Sender Type",
-            options=[MESSAGE_SENDER_AI, MESSAGE_SENDER_USER, "Machine and User"],
-            value="Machine and User",
-            info="Filter by sender type.",
-            advanced=True,
-        ),
-        MessageTextInput(
-            name="sender",
-            display_name="Sender",
-            info="The sender of the message. Might be Machine or User. "
-            "If empty, the current sender parameter will be used.",
-            advanced=True,
-        ),
-        MessageTextInput(
-            name="sender_name",
-            display_name="Sender Name",
-            info="Filter by sender name.",
-            advanced=True,
-            show=False,
-        ),
-        IntInput(
-            name="n_messages",
-            display_name="Number of Messages",
-            value=100,
-            info="Number of messages to retrieve.",
-            advanced=True,
-            show=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.",
-            value="",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="order",
-            display_name="Order",
-            options=["Ascending", "Descending"],
-            value="Ascending",
-            info="Order of the messages.",
-            advanced=True,
-            tool_mode=True,
-            required=True,
-        ),
-        MultilineInput(
-            name="template",
-            display_name="Template",
-            info="The template to use for formatting the data. "
-            "It can contain the keys {text}, {sender} or any other key in the message data.",
-            value="{sender_name}: {text}",
-            advanced=True,
-            show=False,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Message", name="messages_text", method="retrieve_messages_as_text", dynamic=True),
-        Output(display_name="Dataframe", name="dataframe", method="retrieve_messages_dataframe", dynamic=True),
-    ]
-
-    def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
-        """Dynamically show only the relevant output based on the selected output type."""
-        if field_name == "mode":
-            # Start with empty outputs
-            frontend_node["outputs"] = []
-            if field_value == "Store":
-                frontend_node["outputs"] = [
-                    Output(
-                        display_name="Stored Messages",
-                        name="stored_messages",
-                        method="store_message",
-                        hidden=True,
-                        dynamic=True,
-                    )
-                ]
-            if field_value == "Retrieve":
-                frontend_node["outputs"] = [
-                    Output(
-                        display_name="Messages", name="messages_text", method="retrieve_messages_as_text", dynamic=True
-                    ),
-                    Output(
-                        display_name="Dataframe", name="dataframe", method="retrieve_messages_dataframe", dynamic=True
-                    ),
-                ]
-        return frontend_node
-
-    async def store_message(self) -> Message:
-        message = Message(text=self.message) if isinstance(self.message, str) else self.message
-
-        message.session_id = self.session_id or message.session_id
-        message.sender = self.sender or message.sender or MESSAGE_SENDER_AI
-        message.sender_name = self.sender_name or message.sender_name or MESSAGE_SENDER_NAME_AI
-
-        stored_messages: list[Message] = []
-
-        if self.memory:
-            self.memory.session_id = message.session_id
-            lc_message = message.to_lc_message()
-            await self.memory.aadd_messages([lc_message])
-
-            stored_messages = await self.memory.aget_messages() or []
-
-            stored_messages = [Message.from_lc_message(m) for m in stored_messages] if stored_messages else []
-
-            if message.sender:
-                stored_messages = [m for m in stored_messages if m.sender == message.sender]
-        else:
-            await astore_message(message, flow_id=self.graph.flow_id)
-            stored_messages = (
-                await aget_messages(
-                    session_id=message.session_id, sender_name=message.sender_name, sender=message.sender
-                )
-                or []
-            )
-
-        if not stored_messages:
-            msg = "No messages were stored. Please ensure that the session ID and sender are properly set."
-            raise ValueError(msg)
-
-        stored_message = stored_messages[0]
-        self.status = stored_message
-        return stored_message
-
-    async def retrieve_messages(self) -> Data:
-        sender_type = self.sender_type
-        sender_name = self.sender_name
-        session_id = self.session_id
-        n_messages = self.n_messages
-        order = "DESC" if self.order == "Descending" else "ASC"
-
-        if sender_type == "Machine and User":
-            sender_type = None
-
-        if self.memory and not hasattr(self.memory, "aget_messages"):
-            memory_name = type(self.memory).__name__
-            err_msg = f"External Memory object ({memory_name}) must have 'aget_messages' method."
-            raise AttributeError(err_msg)
-        # Check if n_messages is None or 0
-        if n_messages == 0:
-            stored = []
-        elif self.memory:
-            # override session_id
-            self.memory.session_id = session_id
-
-            stored = await self.memory.aget_messages()
-            # langchain memories are supposed to return messages in ascending order
-
-            if order == "DESC":
-                stored = stored[::-1]
-            if n_messages:
-                stored = stored[-n_messages:] if order == "ASC" else stored[:n_messages]
-            stored = [Message.from_lc_message(m) for m in stored]
-            if sender_type:
-                expected_type = MESSAGE_SENDER_AI if sender_type == MESSAGE_SENDER_AI else MESSAGE_SENDER_USER
-                stored = [m for m in stored if m.type == expected_type]
-        else:
-            # For internal memory, we always fetch the last N messages by ordering by DESC
-            stored = await aget_messages(
-                sender=sender_type,
-                sender_name=sender_name,
-                session_id=session_id,
-                limit=10000,
-                order=order,
-            )
-            if n_messages:
-                stored = stored[-n_messages:] if order == "ASC" else stored[:n_messages]
-
-        # self.status = stored
-        return cast("Data", stored)
-
-    async def retrieve_messages_as_text(self) -> Message:
-        stored_text = data_to_text(self.template, await self.retrieve_messages())
-        # self.status = stored_text
-        return Message(text=stored_text)
-
-    async def retrieve_messages_dataframe(self) -> DataFrame:
-        """Convert the retrieved messages into a DataFrame.
-
-        Returns:
-            DataFrame: A DataFrame containing the message data.
-        """
-        messages = await self.retrieve_messages()
-        return DataFrame(messages)
-
-    def update_build_config(
-        self,
-        build_config: dotdict,
-        field_value: Any,  # noqa: ARG002
-        field_name: str | None = None,  # noqa: ARG002
-    ) -> dotdict:
-        return set_current_fields(
-            build_config=build_config,
-            action_fields=self.mode_config,
-            selected_action=build_config["mode"]["value"],
-            default_fields=self.default_keys,
-            func=set_field_display,
-        )