lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/azure/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.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__)

lfx/components/azure/azure_openai.py

@@ -0,0 +1,95 @@
+from langchain_openai import AzureChatOpenAI
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import MessageTextInput
+from lfx.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.get_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

lfx/components/azure/azure_openai_embeddings.py

@@ -0,0 +1,83 @@
+from langchain_openai import AzureOpenAIEmbeddings
+
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
+from lfx.field_typing import Embeddings
+from lfx.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

lfx/components/baidu/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.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__)

lfx/components/baidu/baidu_qianfan_chat.py

@@ -0,0 +1,113 @@
+from langchain_community.chat_models.baidu_qianfan_endpoint import QianfanChatEndpoint
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing.constants import LanguageModel
+from lfx.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.get_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

lfx/components/bing/__init__.py

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

lfx/components/bing/bing_search_api.py

@@ -0,0 +1,61 @@
+from typing import cast
+
+from langchain_community.tools.bing_search import BingSearchResults
+from langchain_community.utilities import BingSearchAPIWrapper
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import IntInput, MessageTextInput, MultilineInput, SecretStrInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.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))

lfx/components/cassandra/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.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__)