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

langflow/base/models/model.py

@@ -1,375 +0,0 @@
-import importlib
-import json
-import warnings
-from abc import abstractmethod
-
-from langchain_core.language_models import BaseChatModel
-from langchain_core.language_models.llms import LLM
-from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
-from langchain_core.output_parsers import BaseOutputParser
-
-from langflow.base.constants import STREAM_INFO_TEXT
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing import LanguageModel
-from langflow.inputs.inputs import BoolInput, InputTypes, MessageInput, MultilineInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-from langflow.utils.constants import MESSAGE_SENDER_AI
-
-# Enabled detailed thinking for NVIDIA reasoning models.
-#
-# Models are trained with this exact string. Do not update.
-DETAILED_THINKING_PREFIX = "detailed thinking on\n\n"
-
-
-class LCModelComponent(Component):
-    display_name: str = "Model Name"
-    description: str = "Model Description"
-    trace_type = "llm"
-    metadata = {
-        "keywords": [
-            "model",
-            "llm",
-            "language model",
-            "large language model",
-        ],
-    }
-
-    # Optional output parser to pass to the runnable. Subclasses may allow the user to input an `output_parser`
-    output_parser: BaseOutputParser | None = None
-
-    _base_inputs: list[InputTypes] = [
-        MessageInput(name="input_value", display_name="Input"),
-        MultilineInput(
-            name="system_message",
-            display_name="System Message",
-            info="System message to pass to the model.",
-            advanced=False,
-        ),
-        BoolInput(name="stream", display_name="Stream", info=STREAM_INFO_TEXT, advanced=True),
-    ]
-
-    outputs = [
-        Output(display_name="Model Response", name="text_output", method="text_response"),
-        Output(display_name="Language Model", name="model_output", method="build_model"),
-    ]
-
-    def _get_exception_message(self, e: Exception):
-        return str(e)
-
-    def supports_tool_calling(self, model: LanguageModel) -> bool:
-        try:
-            # Check if the bind_tools method is the same as the base class's method
-            if model.bind_tools is BaseChatModel.bind_tools:
-                return False
-
-            def test_tool(x: int) -> int:
-                return x
-
-            model_with_tool = model.bind_tools([test_tool])
-            return hasattr(model_with_tool, "tools") and len(model_with_tool.tools) > 0
-        except (AttributeError, TypeError, ValueError):
-            return False
-
-    def _validate_outputs(self) -> None:
-        # At least these two outputs must be defined
-        required_output_methods = ["text_response", "build_model"]
-        output_names = [output.name for output in self.outputs]
-        for method_name in required_output_methods:
-            if method_name not in output_names:
-                msg = f"Output with name '{method_name}' must be defined."
-                raise ValueError(msg)
-            if not hasattr(self, method_name):
-                msg = f"Method '{method_name}' must be defined."
-                raise ValueError(msg)
-
-    async def text_response(self) -> Message:
-        output = self.build_model()
-        result = await self.get_chat_result(
-            runnable=output, stream=self.stream, input_value=self.input_value, system_message=self.system_message
-        )
-        self.status = result
-        return result
-
-    def get_result(self, *, runnable: LLM, stream: bool, input_value: str):
-        """Retrieves the result from the output of a Runnable object.
-
-        Args:
-            runnable (Runnable): The runnable to retrieve the result from.
-            stream (bool): Indicates whether to use streaming or invocation mode.
-            input_value (str): The input value to pass to the output object.
-
-        Returns:
-            The result obtained from the output object.
-        """
-        try:
-            if stream:
-                result = runnable.stream(input_value)
-            else:
-                message = runnable.invoke(input_value)
-                result = message.content if hasattr(message, "content") else message
-                self.status = result
-        except Exception as e:
-            if message := self._get_exception_message(e):
-                raise ValueError(message) from e
-            raise
-
-        return result
-
-    def build_status_message(self, message: AIMessage):
-        """Builds a status message from an AIMessage object.
-
-        Args:
-            message (AIMessage): The AIMessage object to build the status message from.
-
-        Returns:
-            The status message.
-        """
-        if message.response_metadata:
-            # Build a well formatted status message
-            content = message.content
-            response_metadata = message.response_metadata
-            openai_keys = ["token_usage", "model_name", "finish_reason"]
-            inner_openai_keys = ["completion_tokens", "prompt_tokens", "total_tokens"]
-            anthropic_keys = ["model", "usage", "stop_reason"]
-            inner_anthropic_keys = ["input_tokens", "output_tokens"]
-            if all(key in response_metadata for key in openai_keys) and all(
-                key in response_metadata["token_usage"] for key in inner_openai_keys
-            ):
-                token_usage = response_metadata["token_usage"]
-                status_message = {
-                    "tokens": {
-                        "input": token_usage["prompt_tokens"],
-                        "output": token_usage["completion_tokens"],
-                        "total": token_usage["total_tokens"],
-                        "stop_reason": response_metadata["finish_reason"],
-                        "response": content,
-                    }
-                }
-
-            elif all(key in response_metadata for key in anthropic_keys) and all(
-                key in response_metadata["usage"] for key in inner_anthropic_keys
-            ):
-                usage = response_metadata["usage"]
-                status_message = {
-                    "tokens": {
-                        "input": usage["input_tokens"],
-                        "output": usage["output_tokens"],
-                        "stop_reason": response_metadata["stop_reason"],
-                        "response": content,
-                    }
-                }
-            else:
-                status_message = f"Response: {content}"  # type: ignore[assignment]
-        else:
-            status_message = f"Response: {message.content}"  # type: ignore[assignment]
-        return status_message
-
-    async def get_chat_result(
-        self,
-        *,
-        runnable: LanguageModel,
-        stream: bool,
-        input_value: str | Message,
-        system_message: str | None = None,
-    ) -> Message:
-        # NVIDIA reasoning models use detailed thinking
-        if getattr(self, "detailed_thinking", False):
-            system_message = DETAILED_THINKING_PREFIX + (system_message or "")
-
-        return await self._get_chat_result(
-            runnable=runnable,
-            stream=stream,
-            input_value=input_value,
-            system_message=system_message,
-        )
-
-    async def _get_chat_result(
-        self,
-        *,
-        runnable: LanguageModel,
-        stream: bool,
-        input_value: str | Message,
-        system_message: str | None = None,
-    ) -> Message:
-        """Get chat result from a language model.
-
-        This method handles the core logic of getting a response from a language model,
-        including handling different input types, streaming, and error handling.
-
-        Args:
-            runnable (LanguageModel): The language model to use for generating responses
-            stream (bool): Whether to stream the response
-            input_value (str | Message): The input to send to the model
-            system_message (str | None, optional): System message to prepend. Defaults to None.
-
-        Returns:
-            The model response, either as a Message object or raw content
-
-        Raises:
-            ValueError: If the input message is empty or if there's an error during model invocation
-        """
-        messages: list[BaseMessage] = []
-        if not input_value and not system_message:
-            msg = "The message you want to send to the model is empty."
-            raise ValueError(msg)
-        system_message_added = False
-        message = None
-        if input_value:
-            if isinstance(input_value, Message):
-                with warnings.catch_warnings():
-                    warnings.simplefilter("ignore")
-                    if "prompt" in input_value:
-                        prompt = input_value.load_lc_prompt()
-                        if system_message:
-                            prompt.messages = [
-                                SystemMessage(content=system_message),
-                                *prompt.messages,  # type: ignore[has-type]
-                            ]
-                            system_message_added = True
-                        runnable = prompt | runnable
-                    else:
-                        messages.append(input_value.to_lc_message())
-            else:
-                messages.append(HumanMessage(content=input_value))
-
-        if system_message and not system_message_added:
-            messages.insert(0, SystemMessage(content=system_message))
-        inputs: list | dict = messages or {}
-        lf_message = None
-        try:
-            # TODO: Depreciated Feature to be removed in upcoming release
-            if hasattr(self, "output_parser") and self.output_parser is not None:
-                runnable |= self.output_parser
-
-            runnable = runnable.with_config(
-                {
-                    "run_name": self.display_name,
-                    "project_name": self.get_project_name(),
-                    "callbacks": self.get_langchain_callbacks(),
-                }
-            )
-            if stream:
-                lf_message, result = await self._handle_stream(runnable, inputs)
-            else:
-                message = await runnable.ainvoke(inputs)
-                result = message.content if hasattr(message, "content") else message
-            if isinstance(message, AIMessage):
-                status_message = self.build_status_message(message)
-                self.status = status_message
-            elif isinstance(result, dict):
-                result = json.dumps(message, indent=4)
-                self.status = result
-            else:
-                self.status = result
-        except Exception as e:
-            if message := self._get_exception_message(e):
-                raise ValueError(message) from e
-            raise
-        return lf_message or Message(text=result)
-
-    async def _handle_stream(self, runnable, inputs):
-        """Handle streaming responses from the language model.
-
-        Args:
-            runnable: The language model configured for streaming
-            inputs: The inputs to send to the model
-
-        Returns:
-            tuple: (Message object if connected to chat output, model result)
-        """
-        lf_message = None
-        if self.is_connected_to_chat_output():
-            # Add a Message
-            if hasattr(self, "graph"):
-                session_id = self.graph.session_id
-            elif hasattr(self, "_session_id"):
-                session_id = self._session_id
-            else:
-                session_id = None
-            model_message = Message(
-                text=runnable.astream(inputs),
-                sender=MESSAGE_SENDER_AI,
-                sender_name="AI",
-                properties={"icon": self.icon, "state": "partial"},
-                session_id=session_id,
-            )
-            model_message.properties.source = self._build_source(self._id, self.display_name, self)
-            lf_message = await self.send_message(model_message)
-            result = lf_message.text
-        else:
-            message = await runnable.ainvoke(inputs)
-            result = message.content if hasattr(message, "content") else message
-        return lf_message, result
-
-    @abstractmethod
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        """Implement this method to build the model."""
-
-    def get_llm(self, provider_name: str, model_info: dict[str, dict[str, str | list[InputTypes]]]) -> LanguageModel:
-        """Get LLM model based on provider name and inputs.
-
-        Args:
-            provider_name: Name of the model provider (e.g., "OpenAI", "Azure OpenAI")
-            inputs: Dictionary of input parameters for the model
-            model_info: Dictionary of model information
-
-        Returns:
-            Built LLM model instance
-        """
-        try:
-            if provider_name not in [model.get("display_name") for model in model_info.values()]:
-                msg = f"Unknown model provider: {provider_name}"
-                raise ValueError(msg)
-
-            # Find the component class name from MODEL_INFO in a single iteration
-            component_info, module_name = next(
-                ((info, key) for key, info in model_info.items() if info.get("display_name") == provider_name),
-                (None, None),
-            )
-            if not component_info:
-                msg = f"Component information not found for {provider_name}"
-                raise ValueError(msg)
-            component_inputs = component_info.get("inputs", [])
-            # Get the component class from the models module
-            # Ensure component_inputs is a list of the expected types
-            if not isinstance(component_inputs, list):
-                component_inputs = []
-
-            import warnings
-
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore", message="Support for class-based `config` is deprecated", category=DeprecationWarning
-                )
-                warnings.filterwarnings("ignore", message="Valid config keys have changed in V2", category=UserWarning)
-                models_module = importlib.import_module("langflow.components.models")
-                component_class = getattr(models_module, str(module_name))
-                component = component_class()
-
-            return self.build_llm_model_from_inputs(component, component_inputs)
-        except Exception as e:
-            msg = f"Error building {provider_name} language model"
-            raise ValueError(msg) from e
-
-    def build_llm_model_from_inputs(
-        self, component: Component, inputs: list[InputTypes], prefix: str = ""
-    ) -> LanguageModel:
-        """Build LLM model from component and inputs.
-
-        Args:
-            component: LLM component instance
-            inputs: Dictionary of input parameters for the model
-            prefix: Prefix for the input names
-        Returns:
-            Built LLM model instance
-        """
-        # Ensure prefix is a string
-        prefix = prefix or ""
-        # Filter inputs to only include valid component input names
-        input_data = {
-            str(component_input.name): getattr(self, f"{prefix}{component_input.name}", None)
-            for component_input in inputs
-        }
-
-        return component.set(**input_data).build_model()

langflow/base/models/model_input_constants.py

@@ -1,299 +0,0 @@
-from typing_extensions import TypedDict
-
-from langflow.base.models.model import LCModelComponent
-from langflow.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
-from langflow.components.anthropic.anthropic import AnthropicModelComponent
-from langflow.components.azure.azure_openai import AzureChatOpenAIComponent
-from langflow.components.google.google_generative_ai import GoogleGenerativeAIComponent
-from langflow.components.groq.groq import GroqModel
-from langflow.components.nvidia.nvidia import NVIDIAModelComponent
-from langflow.components.openai.openai_chat_model import OpenAIModelComponent
-from langflow.components.sambanova.sambanova import SambaNovaComponent
-from langflow.inputs.inputs import InputTypes, SecretStrInput
-from langflow.template.field.base import Input
-
-
-class ModelProvidersDict(TypedDict):
-    fields: dict
-    inputs: list[InputTypes]
-    prefix: str
-    component_class: LCModelComponent
-    icon: str
-    is_active: bool
-
-
-def get_filtered_inputs(component_class):
-    base_input_names = {field.name for field in LCModelComponent._base_inputs}
-    component_instance = component_class()
-
-    return [process_inputs(input_) for input_ in component_instance.inputs if input_.name not in base_input_names]
-
-
-def process_inputs(component_data: Input):
-    """Processes and modifies an input configuration based on its type or name.
-
-    Adjusts properties such as value, advanced status, real-time refresh, and additional information for specific
-    input types or names to ensure correct behavior in the UI and provider integration.
-
-    Args:
-        component_data: The input configuration to process.
-
-    Returns:
-        The modified input configuration.
-    """
-    if isinstance(component_data, SecretStrInput):
-        component_data.value = ""
-        component_data.load_from_db = False
-        component_data.real_time_refresh = True
-        if component_data.name == "api_key":
-            component_data.required = False
-    elif component_data.name == "tool_model_enabled":
-        component_data.advanced = True
-        component_data.value = True
-    elif component_data.name in {"temperature", "base_url"}:
-        component_data = set_advanced_true(component_data)
-    elif component_data.name == "model_name":
-        component_data = set_real_time_refresh_false(component_data)
-        component_data = add_combobox_true(component_data)
-        component_data = add_info(
-            component_data,
-            "To see the model names, first choose a provider. Then, enter your API key and click the refresh button "
-            "next to the model name.",
-        )
-    return component_data
-
-
-def set_advanced_true(component_input):
-    component_input.advanced = True
-    return component_input
-
-
-def set_real_time_refresh_false(component_input):
-    component_input.real_time_refresh = False
-    return component_input
-
-
-def add_info(component_input, info_str: str):
-    component_input.info = info_str
-    return component_input
-
-
-def add_combobox_true(component_input):
-    component_input.combobox = True
-    return component_input
-
-
-def create_input_fields_dict(inputs: list[Input], prefix: str) -> dict[str, Input]:
-    return {f"{prefix}{input_.name}": input_.to_dict() for input_ in inputs}
-
-
-def _get_google_generative_ai_inputs_and_fields():
-    try:
-        from langflow.components.google.google_generative_ai import GoogleGenerativeAIComponent
-
-        google_generative_ai_inputs = get_filtered_inputs(GoogleGenerativeAIComponent)
-    except ImportError as e:
-        msg = (
-            "Google Generative AI is not installed. Please install it with "
-            "`pip install langchain-google-generative-ai`."
-        )
-        raise ImportError(msg) from e
-    return google_generative_ai_inputs, create_input_fields_dict(google_generative_ai_inputs, "")
-
-
-def _get_openai_inputs_and_fields():
-    try:
-        from langflow.components.openai.openai_chat_model import OpenAIModelComponent
-
-        openai_inputs = get_filtered_inputs(OpenAIModelComponent)
-    except ImportError as e:
-        msg = "OpenAI is not installed. Please install it with `pip install langchain-openai`."
-        raise ImportError(msg) from e
-    return openai_inputs, create_input_fields_dict(openai_inputs, "")
-
-
-def _get_azure_inputs_and_fields():
-    try:
-        from langflow.components.azure.azure_openai import AzureChatOpenAIComponent
-
-        azure_inputs = get_filtered_inputs(AzureChatOpenAIComponent)
-    except ImportError as e:
-        msg = "Azure OpenAI is not installed. Please install it with `pip install langchain-azure-openai`."
-        raise ImportError(msg) from e
-    return azure_inputs, create_input_fields_dict(azure_inputs, "")
-
-
-def _get_groq_inputs_and_fields():
-    try:
-        from langflow.components.groq.groq import GroqModel
-
-        groq_inputs = get_filtered_inputs(GroqModel)
-    except ImportError as e:
-        msg = "Groq is not installed. Please install it with `pip install langchain-groq`."
-        raise ImportError(msg) from e
-    return groq_inputs, create_input_fields_dict(groq_inputs, "")
-
-
-def _get_anthropic_inputs_and_fields():
-    try:
-        from langflow.components.anthropic.anthropic import AnthropicModelComponent
-
-        anthropic_inputs = get_filtered_inputs(AnthropicModelComponent)
-    except ImportError as e:
-        msg = "Anthropic is not installed. Please install it with `pip install langchain-anthropic`."
-        raise ImportError(msg) from e
-    return anthropic_inputs, create_input_fields_dict(anthropic_inputs, "")
-
-
-def _get_nvidia_inputs_and_fields():
-    try:
-        from langflow.components.nvidia.nvidia import NVIDIAModelComponent
-
-        nvidia_inputs = get_filtered_inputs(NVIDIAModelComponent)
-    except ImportError as e:
-        msg = "NVIDIA is not installed. Please install it with `pip install langchain-nvidia`."
-        raise ImportError(msg) from e
-    return nvidia_inputs, create_input_fields_dict(nvidia_inputs, "")
-
-
-def _get_amazon_bedrock_inputs_and_fields():
-    try:
-        from langflow.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
-
-        amazon_bedrock_inputs = get_filtered_inputs(AmazonBedrockComponent)
-    except ImportError as e:
-        msg = "Amazon Bedrock is not installed. Please install it with `pip install langchain-amazon-bedrock`."
-        raise ImportError(msg) from e
-    return amazon_bedrock_inputs, create_input_fields_dict(amazon_bedrock_inputs, "")
-
-
-def _get_sambanova_inputs_and_fields():
-    try:
-        from langflow.components.sambanova.sambanova import SambaNovaComponent
-
-        sambanova_inputs = get_filtered_inputs(SambaNovaComponent)
-    except ImportError as e:
-        msg = "SambaNova is not installed. Please install it with `pip install langchain-sambanova`."
-        raise ImportError(msg) from e
-    return sambanova_inputs, create_input_fields_dict(sambanova_inputs, "")
-
-
-MODEL_PROVIDERS_DICT: dict[str, ModelProvidersDict] = {}
-
-# Try to add each provider
-try:
-    openai_inputs, openai_fields = _get_openai_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["OpenAI"] = {
-        "fields": openai_fields,
-        "inputs": openai_inputs,
-        "prefix": "",
-        "component_class": OpenAIModelComponent(),
-        "icon": OpenAIModelComponent.icon,
-        "is_active": True,
-    }
-except ImportError:
-    pass
-
-try:
-    azure_inputs, azure_fields = _get_azure_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["Azure OpenAI"] = {
-        "fields": azure_fields,
-        "inputs": azure_inputs,
-        "prefix": "",
-        "component_class": AzureChatOpenAIComponent(),
-        "icon": AzureChatOpenAIComponent.icon,
-        "is_active": False,
-    }
-except ImportError:
-    pass
-
-try:
-    groq_inputs, groq_fields = _get_groq_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["Groq"] = {
-        "fields": groq_fields,
-        "inputs": groq_inputs,
-        "prefix": "",
-        "component_class": GroqModel(),
-        "icon": GroqModel.icon,
-        "is_active": True,
-    }
-except ImportError:
-    pass
-
-try:
-    anthropic_inputs, anthropic_fields = _get_anthropic_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["Anthropic"] = {
-        "fields": anthropic_fields,
-        "inputs": anthropic_inputs,
-        "prefix": "",
-        "component_class": AnthropicModelComponent(),
-        "icon": AnthropicModelComponent.icon,
-        "is_active": True,
-    }
-except ImportError:
-    pass
-
-try:
-    nvidia_inputs, nvidia_fields = _get_nvidia_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["NVIDIA"] = {
-        "fields": nvidia_fields,
-        "inputs": nvidia_inputs,
-        "prefix": "",
-        "component_class": NVIDIAModelComponent(),
-        "icon": NVIDIAModelComponent.icon,
-        "is_active": False,
-    }
-except ImportError:
-    pass
-
-try:
-    bedrock_inputs, bedrock_fields = _get_amazon_bedrock_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["Amazon Bedrock"] = {
-        "fields": bedrock_fields,
-        "inputs": bedrock_inputs,
-        "prefix": "",
-        "component_class": AmazonBedrockComponent(),
-        "icon": AmazonBedrockComponent.icon,
-        "is_active": False,
-    }
-except ImportError:
-    pass
-
-try:
-    google_generative_ai_inputs, google_generative_ai_fields = _get_google_generative_ai_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["Google Generative AI"] = {
-        "fields": google_generative_ai_fields,
-        "inputs": google_generative_ai_inputs,
-        "prefix": "",
-        "component_class": GoogleGenerativeAIComponent(),
-        "icon": GoogleGenerativeAIComponent.icon,
-        "is_active": True,
-    }
-except ImportError:
-    pass
-
-try:
-    sambanova_inputs, sambanova_fields = _get_sambanova_inputs_and_fields()
-    MODEL_PROVIDERS_DICT["SambaNova"] = {
-        "fields": sambanova_fields,
-        "inputs": sambanova_inputs,
-        "prefix": "",
-        "component_class": SambaNovaComponent(),
-        "icon": SambaNovaComponent.icon,
-        "is_active": False,
-    }
-except ImportError:
-    pass
-
-# Expose only active providers ----------------------------------------------
-ACTIVE_MODEL_PROVIDERS_DICT: dict[str, ModelProvidersDict] = {
-    name: prov for name, prov in MODEL_PROVIDERS_DICT.items() if prov.get("is_active", True)
-}
-
-MODEL_PROVIDERS: list[str] = list(ACTIVE_MODEL_PROVIDERS_DICT.keys())
-
-ALL_PROVIDER_FIELDS: list[str] = [field for prov in ACTIVE_MODEL_PROVIDERS_DICT.values() for field in prov["fields"]]
-
-MODEL_DYNAMIC_UPDATE_FIELDS = ["api_key", "model", "tool_model_enabled", "base_url", "model_name"]
-
-MODELS_METADATA = {name: {"icon": prov["icon"]} for name, prov in ACTIVE_MODEL_PROVIDERS_DICT.items()}