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

langflow/components/helpers/output_parser.py

@@ -1,45 +0,0 @@
-from langchain_core.output_parsers import CommaSeparatedListOutputParser
-
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing.constants import OutputParser
-from langflow.io import DropdownInput, Output
-from langflow.schema.message import Message
-
-
-class OutputParserComponent(Component):
-    display_name = "Output Parser"
-    description = "Transforms the output of an LLM into a specified format."
-    icon = "type"
-    name = "OutputParser"
-    legacy = True
-
-    inputs = [
-        DropdownInput(
-            name="parser_type",
-            display_name="Parser",
-            options=["CSV"],
-            value="CSV",
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Format Instructions",
-            name="format_instructions",
-            info="Pass to a prompt template to include formatting instructions for LLM responses.",
-            method="format_instructions",
-        ),
-        Output(display_name="Output Parser", name="output_parser", method="build_parser"),
-    ]
-
-    def build_parser(self) -> OutputParser:
-        if self.parser_type == "CSV":
-            return CommaSeparatedListOutputParser()
-        msg = "Unsupported or missing parser"
-        raise ValueError(msg)
-
-    def format_instructions(self) -> Message:
-        if self.parser_type == "CSV":
-            return Message(text=CommaSeparatedListOutputParser().get_format_instructions())
-        msg = "Unsupported or missing parser"
-        raise ValueError(msg)

langflow/components/helpers/store_message.py

@@ -1,90 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import (
-    HandleInput,
-    MessageTextInput,
-)
-from langflow.memory import aget_messages, astore_message
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-from langflow.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI
-
-
-class MessageStoreComponent(Component):
-    display_name = "Message Store"
-    description = "Stores a chat message or text into Langflow tables or an external memory."
-    icon = "message-square-text"
-    name = "StoreMessage"
-    legacy = True
-
-    inputs = [
-        MessageTextInput(
-            name="message", display_name="Message", info="The chat message to be stored.", required=True, tool_mode=True
-        ),
-        HandleInput(
-            name="memory",
-            display_name="External Memory",
-            input_types=["Memory"],
-            info="The external memory to store the message. If empty, it will use the Langflow tables.",
-        ),
-        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="The name of the sender. Might be AI or User. If empty, the current sender parameter will be used.",
-            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.",
-            value="",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Stored Messages", name="stored_messages", method="store_message", hidden=True),
-    ]
-
-    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

langflow/components/homeassistant/__init__.py

@@ -1,7 +0,0 @@
-from .home_assistant_control import HomeAssistantControl
-from .list_home_assistant_states import ListHomeAssistantStates
-
-__all__ = [
-    "HomeAssistantControl",
-    "ListHomeAssistantStates",
-]

langflow/components/homeassistant/home_assistant_control.py

@@ -1,152 +0,0 @@
-import json
-from typing import Any
-
-import requests
-from langchain.tools import StructuredTool
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import SecretStrInput, StrInput
-from langflow.schema.data import Data
-
-
-class HomeAssistantControl(LCToolComponent):
-    """This tool is used to control Home Assistant devices.
-
-    A very simple tool to control Home Assistant devices.
-    - The agent only needs to provide action (turn_on, turn_off, toggle) + entity_id (e.g., switch.xxx, light.xxx).
-    - The domain (e.g., 'switch', 'light') is automatically extracted from entity_id.
-    """
-
-    display_name: str = "Home Assistant Control"
-    description: str = (
-        "A very simple tool to control Home Assistant devices. "
-        "Only action (turn_on, turn_off, toggle) and entity_id need to be provided."
-    )
-    documentation: str = "https://developers.home-assistant.io/docs/api/rest/"
-    icon: str = "HomeAssistant"
-
-    # --- Input fields for LangFlow UI (token, URL) ---
-    inputs = [
-        SecretStrInput(
-            name="ha_token",
-            display_name="Home Assistant Token",
-            info="Home Assistant Long-Lived Access Token",
-            required=True,
-        ),
-        StrInput(
-            name="base_url",
-            display_name="Home Assistant URL",
-            info="e.g., http://192.168.0.10:8123",
-            required=True,
-        ),
-        StrInput(
-            name="default_action",
-            display_name="Default Action (Optional)",
-            info="One of turn_on, turn_off, toggle",
-            required=False,
-        ),
-        StrInput(
-            name="default_entity_id",
-            display_name="Default Entity ID (Optional)",
-            info="Default entity ID to control (e.g., switch.unknown_switch_3)",
-            required=False,
-        ),
-    ]
-
-    # --- Parameters exposed to the agent (Pydantic schema) ---
-    class ToolSchema(BaseModel):
-        """Parameters to be passed by the agent: action, entity_id only."""
-
-        action: str = Field(..., description="Home Assistant service name. (One of turn_on, turn_off, toggle)")
-        entity_id: str = Field(
-            ...,
-            description="Entity ID to control (e.g., switch.xxx, light.xxx, cover.xxx, etc.)."
-            "Do not infer; use the list_homeassistant_states tool to retrieve it.",
-        )
-
-    def run_model(self) -> Data:
-        """Used when the 'Run' button is clicked in LangFlow.
-
-        - Uses default_action and default_entity_id entered in the UI.
-        """
-        action = self.default_action or "turn_off"
-        entity_id = self.default_entity_id or "switch.unknown_switch_3"
-
-        result = self._control_device(
-            ha_token=self.ha_token,
-            base_url=self.base_url,
-            action=action,
-            entity_id=entity_id,
-        )
-        return self._make_data_response(result)
-
-    def build_tool(self) -> Tool:
-        """Returns a tool to be used by the agent (LLM).
-
-        - The agent can only pass action and entity_id as arguments.
-        """
-        return StructuredTool.from_function(
-            name="home_assistant_control",
-            description=(
-                "A tool to control Home Assistant devices easily. "
-                "Parameters: action ('turn_on'/'turn_off'/'toggle'), entity_id ('switch.xxx', etc.)."
-                "Entity ID must be obtained using the list_homeassistant_states tool and not guessed."
-            ),
-            func=self._control_device_for_tool,  # Wrapper function below
-            args_schema=self.ToolSchema,
-        )
-
-    def _control_device_for_tool(self, action: str, entity_id: str) -> dict[str, Any] | str:
-        """Function called by the agent.
-
-        -> Internally calls _control_device.
-        """
-        return self._control_device(
-            ha_token=self.ha_token,
-            base_url=self.base_url,
-            action=action,
-            entity_id=entity_id,
-        )
-
-    def _control_device(
-        self,
-        ha_token: str,
-        base_url: str,
-        action: str,
-        entity_id: str,
-    ) -> dict[str, Any] | str:
-        """Actual logic to call the Home Assistant service.
-
-        The domain is extracted from the beginning of the entity_id.
-        Example: entity_id="switch.unknown_switch_3" -> domain="switch".
-        """
-        try:
-            domain = entity_id.split(".")[0]  # switch, light, cover, etc.
-            url = f"{base_url}/api/services/{domain}/{action}"
-
-            headers = {
-                "Authorization": f"Bearer {ha_token}",
-                "Content-Type": "application/json",
-            }
-            payload = {"entity_id": entity_id}
-
-            response = requests.post(url, headers=headers, json=payload, timeout=10)
-            response.raise_for_status()
-
-            return response.json()  # HA response JSON on success
-        except requests.exceptions.RequestException as e:
-            return f"Error: Failed to call service. {e}"
-        except Exception as e:  # noqa: BLE001
-            return f"An unexpected error occurred: {e}"
-
-    def _make_data_response(self, result: dict[str, Any] | str) -> Data:
-        """Returns a response in the LangFlow Data format."""
-        if isinstance(result, str):
-            # Handle error messages
-            return Data(text=result)
-
-        # Convert dict to JSON string
-        formatted_json = json.dumps(result, indent=2, ensure_ascii=False)
-        return Data(data=result, text=formatted_json)

langflow/components/homeassistant/list_home_assistant_states.py

@@ -1,137 +0,0 @@
-import json
-from typing import Any
-
-import requests
-from langchain.tools import StructuredTool
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import SecretStrInput, StrInput
-from langflow.schema.data import Data
-
-
-class ListHomeAssistantStates(LCToolComponent):
-    display_name: str = "List Home Assistant States"
-    description: str = (
-        "Retrieve states from Home Assistant. "
-        "The agent only needs to specify 'filter_domain' (optional). "
-        "Token and base_url are not exposed to the agent."
-    )
-    documentation: str = "https://developers.home-assistant.io/docs/api/rest/"
-    icon = "HomeAssistant"
-
-    # 1) Define fields to be received in LangFlow UI
-    inputs = [
-        SecretStrInput(
-            name="ha_token",
-            display_name="Home Assistant Token",
-            info="Home Assistant Long-Lived Access Token",
-            required=True,
-        ),
-        StrInput(
-            name="base_url",
-            display_name="Home Assistant URL",
-            info="e.g., http://192.168.0.10:8123",
-            required=True,
-        ),
-        StrInput(
-            name="filter_domain",
-            display_name="Default Filter Domain (Optional)",
-            info="light, switch, sensor, etc. (Leave empty to fetch all)",
-            required=False,
-        ),
-    ]
-
-    # 2) Pydantic schema containing only parameters exposed to the agent
-    class ToolSchema(BaseModel):
-        """Parameters to be passed by the agent: filter_domain only."""
-
-        filter_domain: str = Field("", description="Filter domain (e.g., 'light'). If empty, returns all.")
-
-    def run_model(self) -> Data:
-        """Execute the LangFlow component.
-
-        Uses self.ha_token, self.base_url, self.filter_domain as entered in the UI.
-        Triggered when 'Run' is clicked directly without an agent.
-        """
-        filter_domain = self.filter_domain or ""  # Use "" for fetching all states
-        result = self._list_states(
-            ha_token=self.ha_token,
-            base_url=self.base_url,
-            filter_domain=filter_domain,
-        )
-        return self._make_data_response(result)
-
-    def build_tool(self) -> Tool:
-        """Build a tool object to be used by the agent.
-
-        The agent can only pass 'filter_domain' as a parameter.
-        'ha_token' and 'base_url' are not exposed (stored as self attributes).
-        """
-        return StructuredTool.from_function(
-            name="list_homeassistant_states",
-            description=(
-                "Retrieve states from Home Assistant. "
-                "You can provide filter_domain='light', 'switch', etc. to narrow results."
-            ),
-            func=self._list_states_for_tool,  # Wrapper function below
-            args_schema=self.ToolSchema,  # Requires only filter_domain
-        )
-
-    def _list_states_for_tool(self, filter_domain: str = "") -> list[Any] | str:
-        """Execute the tool when called by the agent.
-
-        'ha_token' and 'base_url' are stored in self (not exposed).
-        """
-        return self._list_states(
-            ha_token=self.ha_token,
-            base_url=self.base_url,
-            filter_domain=filter_domain,
-        )
-
-    def _list_states(
-        self,
-        ha_token: str,
-        base_url: str,
-        filter_domain: str = "",
-    ) -> list[Any] | str:
-        """Call the Home Assistant /api/states endpoint."""
-        try:
-            headers = {
-                "Authorization": f"Bearer {ha_token}",
-                "Content-Type": "application/json",
-            }
-            url = f"{base_url}/api/states"
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-
-            all_states = response.json()
-            if filter_domain:
-                return [st for st in all_states if st.get("entity_id", "").startswith(f"{filter_domain}.")]
-
-        except requests.exceptions.RequestException as e:
-            return f"Error: Failed to fetch states. {e}"
-        except (ValueError, TypeError) as e:
-            return f"Error processing response: {e}"
-        return all_states
-
-    def _make_data_response(self, result: list[Any] | str | dict) -> Data:
-        """Format the response into a Data object."""
-        try:
-            if isinstance(result, list):
-                # Wrap list data into a dictionary and convert to text
-                wrapped_result = {"result": result}
-                return Data(data=wrapped_result, text=json.dumps(wrapped_result, indent=2, ensure_ascii=False))
-            if isinstance(result, dict):
-                # Return dictionary as-is
-                return Data(data=result, text=json.dumps(result, indent=2, ensure_ascii=False))
-            if isinstance(result, str):
-                # Return error messages or strings
-                return Data(data={}, text=result)
-
-            # Handle unexpected data types
-            return Data(data={}, text="Error: Unexpected response format.")
-        except (TypeError, ValueError) as e:
-            # Handle specific exceptions during formatting
-            return Data(data={}, text=f"Error: Failed to process response. Details: {e!s}")

langflow/components/huggingface/__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 .huggingface import HuggingFaceEndpointsComponent
-    from .huggingface_inference_api import HuggingFaceInferenceAPIEmbeddingsComponent
-
-_dynamic_imports = {
-    "HuggingFaceEndpointsComponent": "huggingface",
-    "HuggingFaceInferenceAPIEmbeddingsComponent": "huggingface_inference_api",
-}
-
-__all__ = [
-    "HuggingFaceEndpointsComponent",
-    "HuggingFaceInferenceAPIEmbeddingsComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import huggingface 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/huggingface/huggingface.py

@@ -1,197 +0,0 @@
-from typing import Any
-
-from langchain_community.llms.huggingface_endpoint import HuggingFaceEndpoint
-from tenacity import retry, stop_after_attempt, wait_fixed
-
-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 DictInput, DropdownInput, FloatInput, IntInput, SecretStrInput, SliderInput, StrInput
-
-# TODO: langchain_community.llms.huggingface_endpoint is depreciated.
-#  Need to update to langchain_huggingface, but have dependency with langchain_core 0.3.0
-
-# Constants
-DEFAULT_MODEL = "meta-llama/Llama-3.3-70B-Instruct"
-
-
-class HuggingFaceEndpointsComponent(LCModelComponent):
-    display_name: str = "Hugging Face"
-    description: str = "Generate text using Hugging Face Inference APIs."
-    icon = "HuggingFace"
-    name = "HuggingFaceModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        DropdownInput(
-            name="model_id",
-            display_name="Model ID",
-            info="Select a model from Hugging Face Hub",
-            options=[
-                DEFAULT_MODEL,
-                "mistralai/Mixtral-8x7B-Instruct-v0.1",
-                "mistralai/Mistral-7B-Instruct-v0.3",
-                "meta-llama/Llama-3.1-8B-Instruct",
-                "Qwen/Qwen2.5-Coder-32B-Instruct",
-                "Qwen/QwQ-32B-Preview",
-                "openai-community/gpt2",
-                "custom",
-            ],
-            value=DEFAULT_MODEL,
-            required=True,
-            real_time_refresh=True,
-        ),
-        StrInput(
-            name="custom_model",
-            display_name="Custom Model ID",
-            info="Enter a custom model ID from Hugging Face Hub",
-            value="",
-            show=False,
-            required=True,
-        ),
-        IntInput(
-            name="max_new_tokens", display_name="Max New Tokens", value=512, info="Maximum number of generated tokens"
-        ),
-        IntInput(
-            name="top_k",
-            display_name="Top K",
-            advanced=True,
-            info="The number of highest probability vocabulary tokens to keep for top-k-filtering",
-        ),
-        FloatInput(
-            name="top_p",
-            display_name="Top P",
-            value=0.95,
-            advanced=True,
-            info=(
-                "If set to < 1, only the smallest set of most probable tokens with "
-                "probabilities that add up to `top_p` or higher are kept for generation"
-            ),
-        ),
-        FloatInput(
-            name="typical_p",
-            display_name="Typical P",
-            value=0.95,
-            advanced=True,
-            info="Typical Decoding mass.",
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.8,
-            range_spec=RangeSpec(min=0, max=2, step=0.01),
-            info="The value used to module the logits distribution",
-            advanced=True,
-        ),
-        FloatInput(
-            name="repetition_penalty",
-            display_name="Repetition Penalty",
-            info="The parameter for repetition penalty. 1.0 means no penalty.",
-            advanced=True,
-        ),
-        StrInput(
-            name="inference_endpoint",
-            display_name="Inference Endpoint",
-            value="https://api-inference.huggingface.co/models/",
-            info="Custom inference endpoint URL.",
-            required=True,
-        ),
-        DropdownInput(
-            name="task",
-            display_name="Task",
-            options=["text2text-generation", "text-generation", "summarization", "translation"],
-            value="text-generation",
-            advanced=True,
-            info="The task to call the model with. Should be a task that returns `generated_text` or `summary_text`.",
-        ),
-        SecretStrInput(name="huggingfacehub_api_token", display_name="API Token", password=True, required=True),
-        DictInput(name="model_kwargs", display_name="Model Keyword Arguments", advanced=True),
-        IntInput(name="retry_attempts", display_name="Retry Attempts", value=1, advanced=True),
-    ]
-
-    def get_api_url(self) -> str:
-        if "huggingface" in self.inference_endpoint.lower():
-            if self.model_id == "custom":
-                if not self.custom_model:
-                    error_msg = "Custom model ID is required when 'custom' is selected"
-                    raise ValueError(error_msg)
-                return f"{self.inference_endpoint}{self.custom_model}"
-            return f"{self.inference_endpoint}{self.model_id}"
-        return self.inference_endpoint
-
-    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
-        """Update build configuration based on field updates."""
-        try:
-            if field_name is None or field_name == "model_id":
-                # If model_id is custom, show custom model field
-                if field_value == "custom":
-                    build_config["custom_model"]["show"] = True
-                    build_config["custom_model"]["required"] = True
-                else:
-                    build_config["custom_model"]["show"] = False
-                    build_config["custom_model"]["value"] = ""
-
-        except (KeyError, AttributeError) as e:
-            self.log(f"Error updating build config: {e!s}")
-        return build_config
-
-    def create_huggingface_endpoint(
-        self,
-        task: str | None,
-        huggingfacehub_api_token: str | None,
-        model_kwargs: dict[str, Any],
-        max_new_tokens: int,
-        top_k: int | None,
-        top_p: float,
-        typical_p: float | None,
-        temperature: float | None,
-        repetition_penalty: float | None,
-    ) -> HuggingFaceEndpoint:
-        retry_attempts = self.retry_attempts
-        endpoint_url = self.get_api_url()
-
-        @retry(stop=stop_after_attempt(retry_attempts), wait=wait_fixed(2))
-        def _attempt_create():
-            return HuggingFaceEndpoint(
-                endpoint_url=endpoint_url,
-                task=task,
-                huggingfacehub_api_token=huggingfacehub_api_token,
-                model_kwargs=model_kwargs,
-                max_new_tokens=max_new_tokens,
-                top_k=top_k,
-                top_p=top_p,
-                typical_p=typical_p,
-                temperature=temperature,
-                repetition_penalty=repetition_penalty,
-            )
-
-        return _attempt_create()
-
-    def build_model(self) -> LanguageModel:
-        task = self.task or None
-        huggingfacehub_api_token = self.huggingfacehub_api_token
-        model_kwargs = self.model_kwargs or {}
-        max_new_tokens = self.max_new_tokens
-        top_k = self.top_k or None
-        top_p = self.top_p
-        typical_p = self.typical_p or None
-        temperature = self.temperature or 0.8
-        repetition_penalty = self.repetition_penalty or None
-
-        try:
-            llm = self.create_huggingface_endpoint(
-                task=task,
-                huggingfacehub_api_token=huggingfacehub_api_token,
-                model_kwargs=model_kwargs,
-                max_new_tokens=max_new_tokens,
-                top_k=top_k,
-                top_p=top_p,
-                typical_p=typical_p,
-                temperature=temperature,
-                repetition_penalty=repetition_penalty,
-            )
-        except Exception as e:
-            msg = "Could not connect to Hugging Face Endpoints API."
-            raise ValueError(msg) from e
-
-        return llm