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

langflow/components/notdiamond/notdiamond.py

@@ -1,228 +0,0 @@
-import warnings
-
-import requests
-from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.chat_result import get_chat_result
-from langflow.base.models.model_utils import get_model_name
-from langflow.custom.custom_component.component import Component
-from langflow.io import (
-    BoolInput,
-    DropdownInput,
-    HandleInput,
-    MessageInput,
-    MessageTextInput,
-    Output,
-    SecretStrInput,
-    StrInput,
-)
-from langflow.schema.message import Message
-
-ND_MODEL_MAPPING = {
-    "gpt-4o": {"provider": "openai", "model": "gpt-4o"},
-    "gpt-4o-mini": {"provider": "openai", "model": "gpt-4o-mini"},
-    "gpt-4-turbo": {"provider": "openai", "model": "gpt-4-turbo-2024-04-09"},
-    "claude-3-5-haiku-20241022": {"provider": "anthropic", "model": "claude-3-5-haiku-20241022"},
-    "claude-3-5-sonnet-20241022": {"provider": "anthropic", "model": "claude-3-5-sonnet-20241022"},
-    "anthropic.claude-3-5-sonnet-20241022-v2:0": {"provider": "anthropic", "model": "claude-3-5-sonnet-20241022"},
-    "anthropic.claude-3-5-haiku-20241022-v1:0": {"provider": "anthropic", "model": "claude-3-5-haiku-20241022"},
-    "gemini-1.5-pro": {"provider": "google", "model": "gemini-1.5-pro-latest"},
-    "gemini-1.5-flash": {"provider": "google", "model": "gemini-1.5-flash-latest"},
-    "llama-3.1-sonar-large-128k-online": {"provider": "perplexity", "model": "llama-3.1-sonar-large-128k-online"},
-    "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": {
-        "provider": "togetherai",
-        "model": "Meta-Llama-3.1-70B-Instruct-Turbo",
-    },
-    "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo": {
-        "provider": "togetherai",
-        "model": "Meta-Llama-3.1-405B-Instruct-Turbo",
-    },
-    "mistral-large-latest": {"provider": "mistral", "model": "mistral-large-2407"},
-}
-
-
-class NotDiamondComponent(Component):
-    display_name = "Not Diamond Router"
-    description = "Call the right model at the right time with the world's most powerful AI model router."
-    documentation: str = "https://docs.notdiamond.ai/"
-    icon = "NotDiamond"
-    name = "NotDiamond"
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._selected_model_name = None
-
-    inputs = [
-        MessageInput(name="input_value", display_name="Input", required=True),
-        MessageTextInput(
-            name="system_message",
-            display_name="System Message",
-            info="System message to pass to the model.",
-            advanced=False,
-        ),
-        HandleInput(
-            name="models",
-            display_name="Language Models",
-            input_types=["LanguageModel"],
-            required=True,
-            is_list=True,
-            info="Link the models you want to route between.",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="Not Diamond API Key",
-            info="The Not Diamond API Key to use for routing.",
-            advanced=False,
-            value="NOTDIAMOND_API_KEY",
-            required=True,
-        ),
-        StrInput(
-            name="preference_id",
-            display_name="Preference ID",
-            info="The ID of the router preference that was configured via the Dashboard.",
-            advanced=False,
-        ),
-        DropdownInput(
-            name="tradeoff",
-            display_name="Tradeoff",
-            info="The tradeoff between cost and latency for the router to determine the best LLM for a given query.",
-            advanced=False,
-            options=["quality", "cost", "latency"],
-            value="quality",
-        ),
-        BoolInput(
-            name="hash_content",
-            display_name="Hash Content",
-            info="Whether to hash the content before being sent to the NotDiamond API.",
-            advanced=False,
-            value=False,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Output", name="output", method="model_select"),
-        Output(
-            display_name="Selected Model",
-            name="selected_model",
-            method="get_selected_model",
-            required_inputs=["output"],
-        ),
-    ]
-
-    def get_selected_model(self) -> str:
-        return self._selected_model_name
-
-    def model_select(self) -> Message:
-        api_key = SecretStr(self.api_key).get_secret_value() if self.api_key else None
-        input_value = self.input_value
-        system_message = self.system_message
-        messages = self._format_input(input_value, system_message)
-
-        selected_models = []
-        mapped_selected_models = []
-        for model in self.models:
-            model_name = get_model_name(model)
-
-            if model_name in ND_MODEL_MAPPING:
-                selected_models.append(model)
-                mapped_selected_models.append(ND_MODEL_MAPPING[model_name])
-
-        payload = {
-            "messages": messages,
-            "llm_providers": mapped_selected_models,
-            "hash_content": self.hash_content,
-        }
-
-        if self.tradeoff != "quality":
-            payload["tradeoff"] = self.tradeoff
-
-        if self.preference_id and self.preference_id != "":
-            payload["preference_id"] = self.preference_id
-
-        header = {
-            "Authorization": f"Bearer {api_key}",
-            "accept": "application/json",
-            "content-type": "application/json",
-        }
-
-        response = requests.post(
-            "https://api.notdiamond.ai/v2/modelRouter/modelSelect",
-            json=payload,
-            headers=header,
-            timeout=10,
-        )
-
-        result = response.json()
-        chosen_model = self.models[0]  # By default there is a fallback model
-        self._selected_model_name = get_model_name(chosen_model)
-
-        if "providers" not in result:
-            # No provider returned by NotDiamond API, likely failed. Fallback to first model.
-            return self._call_get_chat_result(chosen_model, input_value, system_message)
-
-        providers = result["providers"]
-
-        if len(providers) == 0:
-            # No provider returned by NotDiamond API, likely failed. Fallback to first model.
-            return self._call_get_chat_result(chosen_model, input_value, system_message)
-
-        nd_result = providers[0]
-
-        for nd_model, selected_model in zip(mapped_selected_models, selected_models, strict=False):
-            if nd_model["provider"] == nd_result["provider"] and nd_model["model"] == nd_result["model"]:
-                chosen_model = selected_model
-                self._selected_model_name = get_model_name(chosen_model)
-                break
-
-        return self._call_get_chat_result(chosen_model, input_value, system_message)
-
-    def _call_get_chat_result(self, chosen_model, input_value, system_message):
-        return get_chat_result(
-            runnable=chosen_model,
-            input_value=input_value,
-            system_message=system_message,
-        )
-
-    def _format_input(
-        self,
-        input_value: str | Message,
-        system_message: str | None = None,
-    ):
-        messages: list[BaseMessage] = []
-        if not input_value and not system_message:
-            msg = "The message you want to send to the router is empty."
-            raise ValueError(msg)
-        system_message_added = False
-        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
-                        messages.extend(prompt.messages)
-                    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))
-
-        # Convert Langchain messages to OpenAI format
-        openai_messages = []
-        for msg in messages:
-            if isinstance(msg, HumanMessage):
-                openai_messages.append({"role": "user", "content": msg.content})
-            elif isinstance(msg, AIMessage):
-                openai_messages.append({"role": "assistant", "content": msg.content})
-            elif isinstance(msg, SystemMessage):
-                openai_messages.append({"role": "system", "content": msg.content})
-
-        return openai_messages

langflow/components/novita/__init__.py

@@ -1,32 +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.novita.novita import NovitaModelComponent
-
-_dynamic_imports = {
-    "NovitaModelComponent": "novita",
-}
-
-__all__ = ["NovitaModelComponent"]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import novita 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/novita/novita.py

@@ -1,130 +0,0 @@
-import requests
-from langchain_openai import ChatOpenAI
-from pydantic.v1 import SecretStr
-from typing_extensions import override
-
-from langflow.base.models.model import LCModelComponent
-from langflow.base.models.novita_constants import MODEL_NAMES
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.inputs.inputs import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    HandleInput,
-    IntInput,
-    SecretStrInput,
-    SliderInput,
-)
-
-
-class NovitaModelComponent(LCModelComponent):
-    display_name = "Novita AI"
-    description = "Generates text using Novita AI LLMs (OpenAI compatible)."
-    icon = "Novita"
-    name = "NovitaModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            advanced=True,
-            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
-            range_spec=RangeSpec(min=0, max=128000),
-        ),
-        DictInput(
-            name="model_kwargs",
-            display_name="Model Kwargs",
-            advanced=True,
-            info="Additional keyword arguments to pass to the model.",
-        ),
-        BoolInput(
-            name="json_mode",
-            display_name="JSON Mode",
-            advanced=True,
-            info="If True, it will output JSON regardless of passing a schema.",
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            advanced=False,
-            options=MODEL_NAMES,
-            value=MODEL_NAMES[0],
-            refresh_button=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="Novita API Key",
-            info="The Novita API Key to use for Novita AI models.",
-            advanced=False,
-            value="NOVITA_API_KEY",
-            real_time_refresh=True,
-        ),
-        SliderInput(name="temperature", display_name="Temperature", value=0.1, range_spec=RangeSpec(min=0, max=1)),
-        IntInput(
-            name="seed",
-            display_name="Seed",
-            info="The seed controls the reproducibility of the job.",
-            advanced=True,
-            value=1,
-        ),
-        HandleInput(
-            name="output_parser",
-            display_name="Output Parser",
-            info="The parser to use to parse the output of the model",
-            advanced=True,
-            input_types=["OutputParser"],
-        ),
-    ]
-
-    def get_models(self) -> list[str]:
-        base_url = "https://api.novita.ai/v3/openai"
-        url = f"{base_url}/models"
-
-        headers = {"Content-Type": "application/json"}
-
-        try:
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            model_list = response.json()
-            return [model["id"] for model in model_list.get("data", [])]
-        except requests.RequestException as e:
-            self.status = f"Error fetching models: {e}"
-            return MODEL_NAMES
-
-    @override
-    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
-        if field_name in {"api_key", "model_name"}:
-            models = self.get_models()
-            build_config["model_name"]["options"] = models
-        return build_config
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        api_key = self.api_key
-        temperature = self.temperature
-        model_name: str = self.model_name
-        max_tokens = self.max_tokens
-        model_kwargs = self.model_kwargs or {}
-        json_mode = self.json_mode
-        seed = self.seed
-
-        try:
-            output = ChatOpenAI(
-                model=model_name,
-                api_key=(SecretStr(api_key).get_secret_value() if api_key else None),
-                max_tokens=max_tokens or None,
-                temperature=temperature,
-                model_kwargs=model_kwargs,
-                streaming=self.stream,
-                seed=seed,
-                base_url="https://api.novita.ai/v3/openai",
-            )
-        except Exception as e:
-            msg = "Could not connect to Novita API."
-            raise ValueError(msg) from e
-
-        if json_mode:
-            output = output.bind(response_format={"type": "json_object"})
-
-        return output

langflow/components/nvidia/__init__.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .nvidia import NVIDIAModelComponent
-    from .nvidia_embedding import NVIDIAEmbeddingsComponent
-    from .nvidia_ingest import NvidiaIngestComponent
-    from .nvidia_rerank import NvidiaRerankComponent
-
-    if sys.platform == "win32":
-        from .system_assist import NvidiaSystemAssistComponent
-
-_dynamic_imports = {
-    "NVIDIAModelComponent": "nvidia",
-    "NVIDIAEmbeddingsComponent": "nvidia_embedding",
-    "NvidiaIngestComponent": "nvidia_ingest",
-    "NvidiaRerankComponent": "nvidia_rerank",
-}
-
-if sys.platform == "win32":
-    _dynamic_imports["NvidiaSystemAssistComponent"] = "system_assist"
-    __all__ = [
-        "NVIDIAEmbeddingsComponent",
-        "NVIDIAModelComponent",
-        "NvidiaIngestComponent",
-        "NvidiaRerankComponent",
-        "NvidiaSystemAssistComponent",
-    ]
-else:
-    __all__ = [
-        "NVIDIAEmbeddingsComponent",
-        "NVIDIAModelComponent",
-        "NvidiaIngestComponent",
-        "NvidiaRerankComponent",
-    ]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import nvidia 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/nvidia/nvidia.py

@@ -1,157 +0,0 @@
-from typing import Any
-
-from requests.exceptions import ConnectionError  # noqa: A004
-from urllib3.exceptions import MaxRetryError, NameResolutionError
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput, SliderInput
-from langflow.logging.logger import logger
-from langflow.schema.dotdict import dotdict
-
-
-class NVIDIAModelComponent(LCModelComponent):
-    display_name = "NVIDIA"
-    description = "Generates text using NVIDIA LLMs."
-    icon = "NVIDIA"
-
-    try:
-        import warnings
-
-        # Suppresses repeated warnings about NIM key in langchain_nvidia_ai_endpoints==0.3.8
-        warnings.filterwarnings("ignore", category=UserWarning, module="langchain_nvidia_ai_endpoints._common")
-        from langchain_nvidia_ai_endpoints import ChatNVIDIA
-
-        all_models = ChatNVIDIA().get_available_models()
-    except ImportError as e:
-        msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
-        raise ImportError(msg) from e
-    except (ConnectionError, MaxRetryError, NameResolutionError):
-        logger.warning(
-            "Failed to connect to NVIDIA API. Model list may be unavailable."
-            " Please check your internet connection and API credentials."
-        )
-        all_models = []
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            advanced=True,
-            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            info="The name of the NVIDIA model to use.",
-            advanced=False,
-            value=None,
-            options=[model.id for model in all_models],
-            combobox=True,
-            refresh_button=True,
-        ),
-        BoolInput(
-            name="detailed_thinking",
-            display_name="Detailed Thinking",
-            info="If true, the model will return a detailed thought process. Only supported by reasoning models.",
-            value=False,
-            show=False,
-        ),
-        BoolInput(
-            name="tool_model_enabled",
-            display_name="Enable Tool Models",
-            info="If enabled, only show models that support tool-calling.",
-            advanced=False,
-            value=False,
-            real_time_refresh=True,
-        ),
-        MessageTextInput(
-            name="base_url",
-            display_name="NVIDIA Base URL",
-            value="https://integrate.api.nvidia.com/v1",
-            info="The base URL of the NVIDIA API. Defaults to https://integrate.api.nvidia.com/v1.",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="NVIDIA API Key",
-            info="The NVIDIA API Key.",
-            advanced=False,
-            value="NVIDIA_API_KEY",
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            info="Run inference with this temperature.",
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            advanced=True,
-        ),
-        IntInput(
-            name="seed",
-            display_name="Seed",
-            info="The seed controls the reproducibility of the job.",
-            advanced=True,
-            value=1,
-        ),
-    ]
-
-    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
-        try:
-            from langchain_nvidia_ai_endpoints import ChatNVIDIA
-        except ImportError as e:
-            msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
-            raise ImportError(msg) from e
-
-        # Note: don't include the previous model, as it may not exist in available models from the new base url
-        model = ChatNVIDIA(base_url=self.base_url, api_key=self.api_key)
-        if tool_model_enabled:
-            tool_models = [m for m in model.get_available_models() if m.supports_tools]
-            return [m.id for m in tool_models]
-        return [m.id for m in model.available_models]
-
-    def update_build_config(self, build_config: dotdict, _field_value: Any, field_name: str | None = None):
-        if field_name in {"model_name", "tool_model_enabled", "base_url", "api_key"}:
-            try:
-                ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
-                build_config["model_name"]["options"] = ids
-
-                if "value" not in build_config["model_name"] or build_config["model_name"]["value"] is None:
-                    build_config["model_name"]["value"] = ids[0]
-                elif build_config["model_name"]["value"] not in ids:
-                    build_config["model_name"]["value"] = None
-
-                # TODO: use api to determine if model supports detailed thinking
-                if build_config["model_name"]["value"] == "nemotron":
-                    build_config["detailed_thinking"]["show"] = True
-                else:
-                    build_config["detailed_thinking"]["value"] = False
-                    build_config["detailed_thinking"]["show"] = False
-            except Exception as e:
-                msg = f"Error getting model names: {e}"
-                build_config["model_name"]["value"] = None
-                build_config["model_name"]["options"] = []
-                raise ValueError(msg) from e
-
-        return build_config
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        try:
-            from langchain_nvidia_ai_endpoints import ChatNVIDIA
-        except ImportError as e:
-            msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
-            raise ImportError(msg) from e
-        api_key = self.api_key
-        temperature = self.temperature
-        model_name: str = self.model_name
-        max_tokens = self.max_tokens
-        seed = self.seed
-        return ChatNVIDIA(
-            max_tokens=max_tokens or None,
-            model=model_name,
-            base_url=self.base_url,
-            api_key=api_key,
-            temperature=temperature or 0.1,
-            seed=seed,
-        )

langflow/components/nvidia/nvidia_embedding.py

@@ -1,77 +0,0 @@
-from typing import Any
-
-from langflow.base.embeddings.model import LCEmbeddingsModel
-from langflow.field_typing import Embeddings
-from langflow.inputs.inputs import DropdownInput, SecretStrInput
-from langflow.io import FloatInput, MessageTextInput
-from langflow.schema.dotdict import dotdict
-
-
-class NVIDIAEmbeddingsComponent(LCEmbeddingsModel):
-    display_name: str = "NVIDIA Embeddings"
-    description: str = "Generate embeddings using NVIDIA models."
-    icon = "NVIDIA"
-
-    inputs = [
-        DropdownInput(
-            name="model",
-            display_name="Model",
-            options=[
-                "nvidia/nv-embed-v1",
-                "snowflake/arctic-embed-I",
-            ],
-            value="nvidia/nv-embed-v1",
-            required=True,
-        ),
-        MessageTextInput(
-            name="base_url",
-            display_name="NVIDIA Base URL",
-            refresh_button=True,
-            value="https://integrate.api.nvidia.com/v1",
-            required=True,
-        ),
-        SecretStrInput(
-            name="nvidia_api_key",
-            display_name="NVIDIA API Key",
-            info="The NVIDIA API Key.",
-            advanced=False,
-            value="NVIDIA_API_KEY",
-            required=True,
-        ),
-        FloatInput(
-            name="temperature",
-            display_name="Model Temperature",
-            value=0.1,
-            advanced=True,
-        ),
-    ]
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name == "base_url" and field_value:
-            try:
-                build_model = self.build_embeddings()
-                ids = [model.id for model in build_model.available_models]
-                build_config["model"]["options"] = ids
-                build_config["model"]["value"] = ids[0]
-            except Exception as e:
-                msg = f"Error getting model names: {e}"
-                raise ValueError(msg) from e
-        return build_config
-
-    def build_embeddings(self) -> Embeddings:
-        try:
-            from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings
-        except ImportError as e:
-            msg = "Please install langchain-nvidia-ai-endpoints to use the Nvidia model."
-            raise ImportError(msg) from e
-        try:
-            output = NVIDIAEmbeddings(
-                model=self.model,
-                base_url=self.base_url,
-                temperature=self.temperature,
-                nvidia_api_key=self.nvidia_api_key,
-            )
-        except Exception as e:
-            msg = f"Could not connect to NVIDIA API. Error: {e}"
-            raise ValueError(msg) from e
-        return output