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

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

@@ -1,95 +0,0 @@
-from langchain_openai import AzureChatOpenAI
-
-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 MessageTextInput
-from langflow.io import DropdownInput, IntInput, SecretStrInput, SliderInput
-
-
-class AzureChatOpenAIComponent(LCModelComponent):
-    display_name: str = "Azure OpenAI"
-    description: str = "Generate text using Azure OpenAI LLMs."
-    documentation: str = "https://python.langchain.com/docs/integrations/llms/azure_openai"
-    beta = False
-    icon = "Azure"
-    name = "AzureOpenAIModel"
-
-    AZURE_OPENAI_API_VERSIONS = [
-        "2024-06-01",
-        "2024-07-01-preview",
-        "2024-08-01-preview",
-        "2024-09-01-preview",
-        "2024-10-01-preview",
-        "2023-05-15",
-        "2023-12-01-preview",
-        "2024-02-15-preview",
-        "2024-03-01-preview",
-        "2024-12-01-preview",
-        "2025-01-01-preview",
-        "2025-02-01-preview",
-    ]
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        MessageTextInput(
-            name="azure_endpoint",
-            display_name="Azure Endpoint",
-            info="Your Azure endpoint, including the resource. Example: `https://example-resource.azure.openai.com/`",
-            required=True,
-        ),
-        MessageTextInput(name="azure_deployment", display_name="Deployment Name", required=True),
-        SecretStrInput(name="api_key", display_name="API Key", required=True),
-        DropdownInput(
-            name="api_version",
-            display_name="API Version",
-            options=sorted(AZURE_OPENAI_API_VERSIONS, reverse=True),
-            value=next(
-                (
-                    version
-                    for version in sorted(AZURE_OPENAI_API_VERSIONS, reverse=True)
-                    if not version.endswith("-preview")
-                ),
-                AZURE_OPENAI_API_VERSIONS[0],
-            ),
-        ),
-        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",
-            advanced=True,
-            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        azure_endpoint = self.azure_endpoint
-        azure_deployment = self.azure_deployment
-        api_version = self.api_version
-        api_key = self.api_key
-        temperature = self.temperature
-        max_tokens = self.max_tokens
-        stream = self.stream
-
-        try:
-            output = AzureChatOpenAI(
-                azure_endpoint=azure_endpoint,
-                azure_deployment=azure_deployment,
-                api_version=api_version,
-                api_key=api_key,
-                temperature=temperature,
-                max_tokens=max_tokens or None,
-                streaming=stream,
-            )
-        except Exception as e:
-            msg = f"Could not connect to AzureOpenAI API: {e}"
-            raise ValueError(msg) from e
-
-        return output

langflow/components/azure/azure_openai_embeddings.py

@@ -1,83 +0,0 @@
-from langchain_openai import AzureOpenAIEmbeddings
-
-from langflow.base.models.model import LCModelComponent
-from langflow.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
-from langflow.field_typing import Embeddings
-from langflow.io import DropdownInput, IntInput, MessageTextInput, Output, SecretStrInput
-
-
-class AzureOpenAIEmbeddingsComponent(LCModelComponent):
-    display_name: str = "Azure OpenAI Embeddings"
-    description: str = "Generate embeddings using Azure OpenAI models."
-    documentation: str = "https://python.langchain.com/docs/integrations/text_embedding/azureopenai"
-    icon = "Azure"
-    name = "AzureOpenAIEmbeddings"
-
-    API_VERSION_OPTIONS = [
-        "2022-12-01",
-        "2023-03-15-preview",
-        "2023-05-15",
-        "2023-06-01-preview",
-        "2023-07-01-preview",
-        "2023-08-01-preview",
-    ]
-
-    inputs = [
-        DropdownInput(
-            name="model",
-            display_name="Model",
-            advanced=False,
-            options=OPENAI_EMBEDDING_MODEL_NAMES,
-            value=OPENAI_EMBEDDING_MODEL_NAMES[0],
-        ),
-        MessageTextInput(
-            name="azure_endpoint",
-            display_name="Azure Endpoint",
-            required=True,
-            info="Your Azure endpoint, including the resource. Example: `https://example-resource.azure.openai.com/`",
-        ),
-        MessageTextInput(
-            name="azure_deployment",
-            display_name="Deployment Name",
-            required=True,
-        ),
-        DropdownInput(
-            name="api_version",
-            display_name="API Version",
-            options=API_VERSION_OPTIONS,
-            value=API_VERSION_OPTIONS[-1],
-            advanced=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            required=True,
-        ),
-        IntInput(
-            name="dimensions",
-            display_name="Dimensions",
-            info="The number of dimensions the resulting output embeddings should have. "
-            "Only supported by certain models.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
-    ]
-
-    def build_embeddings(self) -> Embeddings:
-        try:
-            embeddings = AzureOpenAIEmbeddings(
-                model=self.model,
-                azure_endpoint=self.azure_endpoint,
-                azure_deployment=self.azure_deployment,
-                api_version=self.api_version,
-                api_key=self.api_key,
-                dimensions=self.dimensions or None,
-            )
-        except Exception as e:
-            msg = f"Could not connect to AzureOpenAIEmbeddings API: {e}"
-            raise ValueError(msg) from e
-
-        return embeddings

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

@@ -1,113 +0,0 @@
-from langchain_community.chat_models.baidu_qianfan_endpoint import QianfanChatEndpoint
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing.constants import LanguageModel
-from langflow.io import DropdownInput, FloatInput, MessageTextInput, SecretStrInput
-
-
-class QianfanChatEndpointComponent(LCModelComponent):
-    display_name: str = "Qianfan"
-    description: str = "Generate text using Baidu Qianfan LLMs."
-    documentation: str = "https://python.langchain.com/docs/integrations/chat/baidu_qianfan_endpoint"
-    icon = "BaiduQianfan"
-    name = "BaiduQianfanChatModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        DropdownInput(
-            name="model",
-            display_name="Model Name",
-            options=[
-                "EB-turbo-AppBuilder",
-                "Llama-2-70b-chat",
-                "ERNIE-Bot-turbo-AI",
-                "ERNIE-Lite-8K-0308",
-                "ERNIE-Speed",
-                "Qianfan-Chinese-Llama-2-13B",
-                "ERNIE-3.5-8K",
-                "BLOOMZ-7B",
-                "Qianfan-Chinese-Llama-2-7B",
-                "XuanYuan-70B-Chat-4bit",
-                "AquilaChat-7B",
-                "ERNIE-Bot-4",
-                "Llama-2-13b-chat",
-                "ChatGLM2-6B-32K",
-                "ERNIE-Bot",
-                "ERNIE-Speed-128k",
-                "ERNIE-4.0-8K",
-                "Qianfan-BLOOMZ-7B-compressed",
-                "ERNIE Speed",
-                "Llama-2-7b-chat",
-                "Mixtral-8x7B-Instruct",
-                "ERNIE 3.5",
-                "ERNIE Speed-AppBuilder",
-                "ERNIE-Speed-8K",
-                "Yi-34B-Chat",
-            ],
-            info="https://python.langchain.com/docs/integrations/chat/baidu_qianfan_endpoint",
-            value="ERNIE-4.0-8K",
-        ),
-        SecretStrInput(
-            name="qianfan_ak",
-            display_name="Qianfan Ak",
-            info="which you could get from  https://cloud.baidu.com/product/wenxinworkshop",
-        ),
-        SecretStrInput(
-            name="qianfan_sk",
-            display_name="Qianfan Sk",
-            info="which you could get from  https://cloud.baidu.com/product/wenxinworkshop",
-        ),
-        FloatInput(
-            name="top_p",
-            display_name="Top p",
-            info="Model params, only supported in ERNIE-Bot and ERNIE-Bot-turbo",
-            value=0.8,
-            advanced=True,
-        ),
-        FloatInput(
-            name="temperature",
-            display_name="Temperature",
-            info="Model params, only supported in ERNIE-Bot and ERNIE-Bot-turbo",
-            value=0.95,
-        ),
-        FloatInput(
-            name="penalty_score",
-            display_name="Penalty Score",
-            info="Model params, only supported in ERNIE-Bot and ERNIE-Bot-turbo",
-            value=1.0,
-            advanced=True,
-        ),
-        MessageTextInput(
-            name="endpoint", display_name="Endpoint", info="Endpoint of the Qianfan LLM, required if custom model used."
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        model = self.model
-        qianfan_ak = self.qianfan_ak
-        qianfan_sk = self.qianfan_sk
-        top_p = self.top_p
-        temperature = self.temperature
-        penalty_score = self.penalty_score
-        endpoint = self.endpoint
-
-        try:
-            kwargs = {
-                "model": model,
-                "qianfan_ak": qianfan_ak or None,
-                "qianfan_sk": qianfan_sk or None,
-                "top_p": top_p,
-                "temperature": temperature,
-                "penalty_score": penalty_score,
-            }
-
-            if endpoint:  # Only add endpoint if it has a value
-                kwargs["endpoint"] = endpoint
-
-            output = QianfanChatEndpoint(**kwargs)
-
-        except Exception as e:
-            msg = "Could not connect to Baidu Qianfan API."
-            raise ValueError(msg) from e
-
-        return output

langflow/components/bing/__init__.py

@@ -1,3 +0,0 @@
-from .bing_search_api import BingSearchAPIComponent
-
-__all__ = ["BingSearchAPIComponent"]

langflow/components/bing/bing_search_api.py

@@ -1,61 +0,0 @@
-from typing import cast
-
-from langchain_community.tools.bing_search import BingSearchResults
-from langchain_community.utilities import BingSearchAPIWrapper
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import IntInput, MessageTextInput, MultilineInput, SecretStrInput
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-
-class BingSearchAPIComponent(LCToolComponent):
-    display_name = "Bing Search API"
-    description = "Call the Bing Search API."
-    name = "BingSearchAPI"
-    icon = "Bing"
-
-    inputs = [
-        SecretStrInput(name="bing_subscription_key", display_name="Bing Subscription Key"),
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-        ),
-        MessageTextInput(name="bing_search_url", display_name="Bing Search URL", advanced=True),
-        IntInput(name="k", display_name="Number of results", value=4, required=True),
-    ]
-
-    outputs = [
-        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
-        Output(display_name="Tool", name="tool", method="build_tool"),
-    ]
-
-    def run_model(self) -> DataFrame:
-        return self.fetch_content_dataframe()
-
-    def fetch_content(self) -> list[Data]:
-        if self.bing_search_url:
-            wrapper = BingSearchAPIWrapper(
-                bing_search_url=self.bing_search_url, bing_subscription_key=self.bing_subscription_key
-            )
-        else:
-            wrapper = BingSearchAPIWrapper(bing_subscription_key=self.bing_subscription_key)
-        results = wrapper.results(query=self.input_value, num_results=self.k)
-        data = [Data(data=result, text=result["snippet"]) for result in results]
-        self.status = data
-        return data
-
-    def fetch_content_dataframe(self) -> DataFrame:
-        data = self.fetch_content()
-        return DataFrame(data)
-
-    def build_tool(self) -> Tool:
-        if self.bing_search_url:
-            wrapper = BingSearchAPIWrapper(
-                bing_search_url=self.bing_search_url, bing_subscription_key=self.bing_subscription_key
-            )
-        else:
-            wrapper = BingSearchAPIWrapper(bing_subscription_key=self.bing_subscription_key)
-        return cast("Tool", BingSearchResults(api_wrapper=wrapper, num_results=self.k))

langflow/components/cassandra/__init__.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .cassandra import CassandraVectorStoreComponent
-    from .cassandra_chat import CassandraChatMemory
-    from .cassandra_graph import CassandraGraphVectorStoreComponent
-
-_dynamic_imports = {
-    "CassandraVectorStoreComponent": "cassandra",
-    "CassandraGraphVectorStoreComponent": "cassandra_graph",
-    "CassandraChatMemory": "cassandra_chat",
-}
-
-__all__ = [
-    "CassandraChatMemory",
-    "CassandraGraphVectorStoreComponent",
-    "CassandraVectorStoreComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import Cassandra 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__)