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

langflow/components/openai/openai_chat_model.py

@@ -1,158 +0,0 @@
-from typing import Any
-
-from langchain_openai import ChatOpenAI
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.model import LCModelComponent
-from langflow.base.models.openai_constants import (
-    OPENAI_CHAT_MODEL_NAMES,
-    OPENAI_REASONING_MODEL_NAMES,
-)
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.inputs.inputs import BoolInput, DictInput, DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
-from langflow.logging import logger
-
-
-class OpenAIModelComponent(LCModelComponent):
-    display_name = "OpenAI"
-    description = "Generates text using OpenAI LLMs."
-    icon = "OpenAI"
-    name = "OpenAIModel"
-
-    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=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
-            value=OPENAI_CHAT_MODEL_NAMES[0],
-            combobox=True,
-            real_time_refresh=True,
-        ),
-        StrInput(
-            name="openai_api_base",
-            display_name="OpenAI API Base",
-            advanced=True,
-            info="The base URL of the OpenAI API. "
-            "Defaults to https://api.openai.com/v1. "
-            "You can change this to use other APIs like JinaChat, LocalAI and Prem.",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="OpenAI API Key",
-            info="The OpenAI API Key to use for the OpenAI model.",
-            advanced=False,
-            value="OPENAI_API_KEY",
-            required=True,
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            show=True,
-        ),
-        IntInput(
-            name="seed",
-            display_name="Seed",
-            info="The seed controls the reproducibility of the job.",
-            advanced=True,
-            value=1,
-        ),
-        IntInput(
-            name="max_retries",
-            display_name="Max Retries",
-            info="The maximum number of retries to make when generating.",
-            advanced=True,
-            value=5,
-        ),
-        IntInput(
-            name="timeout",
-            display_name="Timeout",
-            info="The timeout for requests to OpenAI completion API.",
-            advanced=True,
-            value=700,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        logger.debug(f"Executing request with model: {self.model_name}")
-        parameters = {
-            "api_key": SecretStr(self.api_key).get_secret_value() if self.api_key else None,
-            "model_name": self.model_name,
-            "max_tokens": self.max_tokens or None,
-            "model_kwargs": self.model_kwargs or {},
-            "base_url": self.openai_api_base or "https://api.openai.com/v1",
-            "max_retries": self.max_retries,
-            "timeout": self.timeout,
-        }
-
-        # TODO: Revisit if/once parameters are supported for reasoning models
-        unsupported_params_for_reasoning_models = ["temperature", "seed"]
-
-        if self.model_name not in OPENAI_REASONING_MODEL_NAMES:
-            parameters["temperature"] = self.temperature if self.temperature is not None else 0.1
-            parameters["seed"] = self.seed
-        else:
-            params_str = ", ".join(unsupported_params_for_reasoning_models)
-            logger.debug(f"{self.model_name} is a reasoning model, {params_str} are not configurable. Ignoring.")
-
-        output = ChatOpenAI(**parameters)
-        if self.json_mode:
-            output = output.bind(response_format={"type": "json_object"})
-
-        return output
-
-    def _get_exception_message(self, e: Exception):
-        """Get a message from an OpenAI exception.
-
-        Args:
-            e (Exception): The exception to get the message from.
-
-        Returns:
-            str: The message from the exception.
-        """
-        try:
-            from openai import BadRequestError
-        except ImportError:
-            return None
-        if isinstance(e, BadRequestError):
-            message = e.body.get("message")
-            if message:
-                return message
-        return None
-
-    def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
-        if field_name in {"base_url", "model_name", "api_key"} and field_value in OPENAI_REASONING_MODEL_NAMES:
-            build_config["temperature"]["show"] = False
-            build_config["seed"]["show"] = False
-            # Hide system_message for o1 models - currently unsupported
-            if field_value.startswith("o1") and "system_message" in build_config:
-                build_config["system_message"]["show"] = False
-        if field_name in {"base_url", "model_name", "api_key"} and field_value in OPENAI_CHAT_MODEL_NAMES:
-            build_config["temperature"]["show"] = True
-            build_config["seed"]["show"] = True
-            if "system_message" in build_config:
-                build_config["system_message"]["show"] = True
-        return build_config

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

@@ -1,202 +0,0 @@
-from collections import defaultdict
-from typing import Any
-
-import httpx
-from langchain_openai import ChatOpenAI
-from pydantic.v1 import SecretStr
-
-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 (
-    DropdownInput,
-    IntInput,
-    SecretStrInput,
-    SliderInput,
-    StrInput,
-)
-
-
-class OpenRouterComponent(LCModelComponent):
-    """OpenRouter API component for language models."""
-
-    display_name = "OpenRouter"
-    description = (
-        "OpenRouter provides unified access to multiple AI models from different providers through a single API."
-    )
-    icon = "OpenRouter"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        SecretStrInput(
-            name="api_key", display_name="OpenRouter API Key", required=True, info="Your OpenRouter API key"
-        ),
-        StrInput(
-            name="site_url",
-            display_name="Site URL",
-            info="Your site URL for OpenRouter rankings",
-            advanced=True,
-        ),
-        StrInput(
-            name="app_name",
-            display_name="App Name",
-            info="Your app name for OpenRouter rankings",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="provider",
-            display_name="Provider",
-            info="The AI model provider",
-            options=["Loading providers..."],
-            value="Loading providers...",
-            real_time_refresh=True,
-            required=True,
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model",
-            info="The model to use for chat completion",
-            options=["Select a provider first"],
-            value="Select a provider first",
-            real_time_refresh=True,
-            required=True,
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.7,
-            range_spec=RangeSpec(min=0, max=2, step=0.01),
-            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
-            advanced=True,
-        ),
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            info="Maximum number of tokens to generate",
-            advanced=True,
-        ),
-    ]
-
-    def fetch_models(self) -> dict[str, list]:
-        """Fetch available models from OpenRouter API and organize them by provider."""
-        url = "https://openrouter.ai/api/v1/models"
-
-        try:
-            with httpx.Client() as client:
-                response = client.get(url)
-                response.raise_for_status()
-
-                models_data = response.json().get("data", [])
-                provider_models = defaultdict(list)
-
-                for model in models_data:
-                    model_id = model.get("id", "")
-                    if "/" in model_id:
-                        provider = model_id.split("/")[0].title()
-                        provider_models[provider].append(
-                            {
-                                "id": model_id,
-                                "name": model.get("name", ""),
-                                "description": model.get("description", ""),
-                                "context_length": model.get("context_length", 0),
-                            }
-                        )
-
-                return dict(provider_models)
-
-        except httpx.HTTPError as e:
-            self.log(f"Error fetching models: {e!s}")
-            return {"Error": [{"id": "error", "name": f"Error fetching models: {e!s}"}]}
-
-    def build_model(self) -> LanguageModel:
-        """Build and return the OpenRouter language model."""
-        model_not_selected = "Please select a model"
-        api_key_required = "API key is required"
-
-        if not self.model_name or self.model_name == "Select a provider first":
-            raise ValueError(model_not_selected)
-
-        if not self.api_key:
-            raise ValueError(api_key_required)
-
-        api_key = SecretStr(self.api_key).get_secret_value()
-
-        # Build base configuration
-        kwargs: dict[str, Any] = {
-            "model": self.model_name,
-            "openai_api_key": api_key,
-            "openai_api_base": "https://openrouter.ai/api/v1",
-            "temperature": self.temperature if self.temperature is not None else 0.7,
-        }
-
-        # Add optional parameters
-        if self.max_tokens:
-            kwargs["max_tokens"] = self.max_tokens
-
-        headers = {}
-        if self.site_url:
-            headers["HTTP-Referer"] = self.site_url
-        if self.app_name:
-            headers["X-Title"] = self.app_name
-
-        if headers:
-            kwargs["default_headers"] = headers
-
-        try:
-            return ChatOpenAI(**kwargs)
-        except (ValueError, httpx.HTTPError) as err:
-            error_msg = f"Failed to build model: {err!s}"
-            self.log(error_msg)
-            raise ValueError(error_msg) from err
-
-    def _get_exception_message(self, e: Exception) -> str | None:
-        """Get a message from an OpenRouter exception.
-
-        Args:
-            e (Exception): The exception to get the message from.
-
-        Returns:
-            str | None: The message from the exception, or None if no specific message can be extracted.
-        """
-        try:
-            from openai import BadRequestError
-
-            if isinstance(e, BadRequestError):
-                message = e.body.get("message")
-                if message:
-                    return message
-        except ImportError:
-            pass
-        return None
-
-    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
-        """Update build configuration based on field updates."""
-        try:
-            if field_name is None or field_name == "provider":
-                provider_models = self.fetch_models()
-                build_config["provider"]["options"] = sorted(provider_models.keys())
-                if build_config["provider"]["value"] not in provider_models:
-                    build_config["provider"]["value"] = build_config["provider"]["options"][0]
-
-            if field_name == "provider" and field_value in self.fetch_models():
-                provider_models = self.fetch_models()
-                models = provider_models[field_value]
-
-                build_config["model_name"]["options"] = [model["id"] for model in models]
-                if models:
-                    build_config["model_name"]["value"] = models[0]["id"]
-
-                tooltips = {
-                    model["id"]: (f"{model['name']}\nContext Length: {model['context_length']}\n{model['description']}")
-                    for model in models
-                }
-                build_config["model_name"]["tooltips"] = tooltips
-
-        except httpx.HTTPError as e:
-            self.log(f"Error updating build config: {e!s}")
-            build_config["provider"]["options"] = ["Error loading providers"]
-            build_config["provider"]["value"] = "Error loading providers"
-            build_config["model_name"]["options"] = ["Error loading models"]
-            build_config["model_name"]["value"] = "Error loading models"
-
-        return build_config

langflow/components/perplexity/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .perplexity import PerplexityComponent
-
-_dynamic_imports = {
-    "PerplexityComponent": "perplexity",
-}
-
-__all__ = [
-    "PerplexityComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import perplexity 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/perplexity/perplexity.py

@@ -1,75 +0,0 @@
-from langchain_community.chat_models import ChatPerplexity
-from pydantic.v1 import SecretStr
-
-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 DropdownInput, FloatInput, IntInput, SecretStrInput, SliderInput
-
-
-class PerplexityComponent(LCModelComponent):
-    display_name = "Perplexity"
-    description = "Generate text using Perplexity LLMs."
-    documentation = "https://python.langchain.com/v0.2/docs/integrations/chat/perplexity/"
-    icon = "Perplexity"
-    name = "PerplexityModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            advanced=False,
-            options=[
-                "llama-3.1-sonar-small-128k-online",
-                "llama-3.1-sonar-large-128k-online",
-                "llama-3.1-sonar-huge-128k-online",
-                "llama-3.1-sonar-small-128k-chat",
-                "llama-3.1-sonar-large-128k-chat",
-                "llama-3.1-8b-instruct",
-                "llama-3.1-70b-instruct",
-            ],
-            value="llama-3.1-sonar-small-128k-online",
-        ),
-        IntInput(name="max_tokens", display_name="Max Output Tokens", info="The maximum number of tokens to generate."),
-        SecretStrInput(
-            name="api_key",
-            display_name="Perplexity API Key",
-            info="The Perplexity API Key to use for the Perplexity model.",
-            advanced=False,
-            required=True,
-        ),
-        SliderInput(
-            name="temperature", display_name="Temperature", value=0.75, range_spec=RangeSpec(min=0, max=2, step=0.05)
-        ),
-        FloatInput(
-            name="top_p",
-            display_name="Top P",
-            info="The maximum cumulative probability of tokens to consider when sampling.",
-            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,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        api_key = SecretStr(self.api_key).get_secret_value()
-        temperature = self.temperature
-        model = self.model_name
-        max_tokens = self.max_tokens
-        top_p = self.top_p
-        n = self.n
-
-        return ChatPerplexity(
-            model=model,
-            temperature=temperature or 0.75,
-            pplx_api_key=api_key,
-            top_p=top_p or None,
-            n=n or 1,
-            max_tokens=max_tokens,
-        )

langflow/components/pgvector/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .pgvector import PGVectorStoreComponent
-
-_dynamic_imports = {
-    "PGVectorStoreComponent": "pgvector",
-}
-
-__all__ = [
-    "PGVectorStoreComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import pgvector 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/pgvector/pgvector.py

@@ -1,72 +0,0 @@
-from langchain_community.vectorstores import PGVector
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.io import HandleInput, IntInput, SecretStrInput, StrInput
-from langflow.schema.data import Data
-from langflow.utils.connection_string_parser import transform_connection_string
-
-
-class PGVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "PGVector"
-    description = "PGVector Vector Store with search capabilities"
-    name = "pgvector"
-    icon = "cpu"
-
-    inputs = [
-        SecretStrInput(name="pg_server_url", display_name="PostgreSQL Server Connection String", required=True),
-        StrInput(name="collection_name", display_name="Table", required=True),
-        *LCVectorStoreComponent.inputs,
-        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"], required=True),
-        IntInput(
-            name="number_of_results",
-            display_name="Number of Results",
-            info="Number of results to return.",
-            value=4,
-            advanced=True,
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> PGVector:
-        # Convert DataFrame to Data if needed using parent's method
-        self.ingest_data = self._prepare_ingest_data()
-
-        documents = []
-        for _input in self.ingest_data or []:
-            if isinstance(_input, Data):
-                documents.append(_input.to_lc_document())
-            else:
-                documents.append(_input)
-
-        connection_string_parsed = transform_connection_string(self.pg_server_url)
-
-        if documents:
-            pgvector = PGVector.from_documents(
-                embedding=self.embedding,
-                documents=documents,
-                collection_name=self.collection_name,
-                connection_string=connection_string_parsed,
-            )
-        else:
-            pgvector = PGVector.from_existing_index(
-                embedding=self.embedding,
-                collection_name=self.collection_name,
-                connection_string=connection_string_parsed,
-            )
-
-        return pgvector
-
-    def search_documents(self) -> list[Data]:
-        vector_store = self.build_vector_store()
-
-        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
-            docs = vector_store.similarity_search(
-                query=self.search_query,
-                k=self.number_of_results,
-            )
-
-            data = docs_to_data(docs)
-            self.status = data
-            return data
-        return []

langflow/components/pinecone/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .pinecone import PineconeVectorStoreComponent
-
-_dynamic_imports = {
-    "PineconeVectorStoreComponent": "pinecone",
-}
-
-__all__ = [
-    "PineconeVectorStoreComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import Pinecone 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__)