langflow-base-nightly 0.5.0.dev25__py3-none-any.whl → 0.5.0.dev27__py3-none-any.whl

langflow/components/__init__.py

@@ -0,0 +1,273 @@
+"""LangFlow Components module."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components import (
+        Notion,
+        agentql,
+        agents,
+        aiml,
+        amazon,
+        anthropic,
+        apify,
+        arxiv,
+        assemblyai,
+        azure,
+        baidu,
+        bing,
+        cleanlab,
+        cloudflare,
+        cohere,
+        composio,
+        confluence,
+        crewai,
+        custom_component,
+        data,
+        datastax,
+        deepseek,
+        docling,
+        duckduckgo,
+        embeddings,
+        exa,
+        firecrawl,
+        git,
+        glean,
+        google,
+        groq,
+        helpers,
+        homeassistant,
+        huggingface,
+        ibm,
+        icosacomputing,
+        input_output,
+        langchain_utilities,
+        langwatch,
+        lmstudio,
+        logic,
+        maritalk,
+        mem0,
+        mistral,
+        models,
+        needle,
+        notdiamond,
+        novita,
+        nvidia,
+        olivya,
+        ollama,
+        openai,
+        openrouter,
+        perplexity,
+        processing,
+        prototypes,
+        redis,
+        sambanova,
+        scrapegraph,
+        searchapi,
+        serpapi,
+        tavily,
+        tools,
+        twelvelabs,
+        unstructured,
+        vectorstores,
+        vertexai,
+        wikipedia,
+        wolframalpha,
+        xai,
+        yahoosearch,
+        youtube,
+        zep,
+    )
+
+_dynamic_imports = {
+    "agents": "langflow.components.agents",
+    "data": "langflow.components.data",
+    "processing": "langflow.components.processing",
+    "vectorstores": "langflow.components.vectorstores",
+    "tools": "langflow.components.tools",
+    "models": "langflow.components.models",
+    "embeddings": "langflow.components.embeddings",
+    "helpers": "langflow.components.helpers",
+    "input_output": "langflow.components.input_output",
+    "logic": "langflow.components.logic",
+    "custom_component": "langflow.components.custom_component",
+    "prototypes": "langflow.components.prototypes",
+    "openai": "langflow.components.openai",
+    "anthropic": "langflow.components.anthropic",
+    "google": "langflow.components.google",
+    "azure": "langflow.components.azure",
+    "huggingface": "langflow.components.huggingface",
+    "ollama": "langflow.components.ollama",
+    "groq": "langflow.components.groq",
+    "cohere": "langflow.components.cohere",
+    "mistral": "langflow.components.mistral",
+    "deepseek": "langflow.components.deepseek",
+    "nvidia": "langflow.components.nvidia",
+    "amazon": "langflow.components.amazon",
+    "vertexai": "langflow.components.vertexai",
+    "xai": "langflow.components.xai",
+    "perplexity": "langflow.components.perplexity",
+    "openrouter": "langflow.components.openrouter",
+    "lmstudio": "langflow.components.lmstudio",
+    "sambanova": "langflow.components.sambanova",
+    "maritalk": "langflow.components.maritalk",
+    "novita": "langflow.components.novita",
+    "olivya": "langflow.components.olivya",
+    "notdiamond": "langflow.components.notdiamond",
+    "needle": "langflow.components.needle",
+    "cloudflare": "langflow.components.cloudflare",
+    "baidu": "langflow.components.baidu",
+    "aiml": "langflow.components.aiml",
+    "ibm": "langflow.components.ibm",
+    "langchain_utilities": "langflow.components.langchain_utilities",
+    "crewai": "langflow.components.crewai",
+    "composio": "langflow.components.composio",
+    "mem0": "langflow.components.mem0",
+    "datastax": "langflow.components.datastax",
+    "cleanlab": "langflow.components.cleanlab",
+    "langwatch": "langflow.components.langwatch",
+    "icosacomputing": "langflow.components.icosacomputing",
+    "homeassistant": "langflow.components.homeassistant",
+    "agentql": "langflow.components.agentql",
+    "assemblyai": "langflow.components.assemblyai",
+    "twelvelabs": "langflow.components.twelvelabs",
+    "docling": "langflow.components.docling",
+    "unstructured": "langflow.components.unstructured",
+    "redis": "langflow.components.redis",
+    "zep": "langflow.components.zep",
+    "bing": "langflow.components.bing",
+    "duckduckgo": "langflow.components.duckduckgo",
+    "serpapi": "langflow.components.serpapi",
+    "searchapi": "langflow.components.searchapi",
+    "tavily": "langflow.components.tavily",
+    "exa": "langflow.components.exa",
+    "glean": "langflow.components.glean",
+    "yahoosearch": "langflow.components.yahoosearch",
+    "apify": "langflow.components.apify",
+    "arxiv": "langflow.components.arxiv",
+    "confluence": "langflow.components.confluence",
+    "firecrawl": "langflow.components.firecrawl",
+    "git": "langflow.components.git",
+    "wikipedia": "langflow.components.wikipedia",
+    "youtube": "langflow.components.youtube",
+    "scrapegraph": "langflow.components.scrapegraph",
+    "Notion": "langflow.components.Notion",
+    "wolframalpha": "langflow.components.wolframalpha",
+}
+
+__all__: list[str] = [
+    "Notion",
+    "agentql",
+    "agents",
+    "aiml",
+    "amazon",
+    "anthropic",
+    "apify",
+    "arxiv",
+    "assemblyai",
+    "azure",
+    "baidu",
+    "bing",
+    "cleanlab",
+    "cloudflare",
+    "cohere",
+    "composio",
+    "confluence",
+    "crewai",
+    "custom_component",
+    "data",
+    "datastax",
+    "deepseek",
+    "docling",
+    "duckduckgo",
+    "embeddings",
+    "exa",
+    "firecrawl",
+    "git",
+    "glean",
+    "google",
+    "groq",
+    "helpers",
+    "homeassistant",
+    "huggingface",
+    "ibm",
+    "icosacomputing",
+    "input_output",
+    "langchain_utilities",
+    "langwatch",
+    "lmstudio",
+    "logic",
+    "maritalk",
+    "mem0",
+    "mistral",
+    "models",
+    "needle",
+    "notdiamond",
+    "novita",
+    "nvidia",
+    "olivya",
+    "ollama",
+    "openai",
+    "openrouter",
+    "perplexity",
+    "processing",
+    "prototypes",
+    "redis",
+    "sambanova",
+    "scrapegraph",
+    "searchapi",
+    "serpapi",
+    "tavily",
+    "tools",
+    "twelvelabs",
+    "unstructured",
+    "vectorstores",
+    "vertexai",
+    "wikipedia",
+    "wolframalpha",
+    "xai",
+    "yahoosearch",
+    "youtube",
+    "zep",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import component modules on attribute access.
+
+    Args:
+        attr_name (str): The attribute/module name to import.
+
+    Returns:
+        Any: The imported module or attribute.
+
+    Raises:
+        AttributeError: If the attribute is not a known component or cannot be imported.
+    """
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        # Use import_mod as in LangChain, passing the module name and package
+        result = import_mod(attr_name, "__module__", __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  # Cache for future access
+    return result
+
+
+def __dir__() -> list[str]:
+    """Return list of available attributes for tab-completion and dir()."""
+    return list(__all__)
+
+
+# Optional: Consistency check (can be removed in production)
+_missing = set(__all__) - set(_dynamic_imports)
+if _missing:
+    msg = f"Missing dynamic import mapping for: {', '.join(_missing)}"
+    raise ImportError(msg)

langflow/components/_importing.py

@@ -0,0 +1,37 @@
+"""Import utilities for LangFlow components."""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+
+def import_mod(
+    attr_name: str,
+    module_name: str | None,
+    package: str | None,
+) -> object:
+    """Import an attribute from a module located in a package.
+
+    This utility function is used in custom __getattr__ methods within __init__.py
+    files to dynamically import attributes.
+
+    Args:
+        attr_name: The name of the attribute to import.
+        module_name: The name of the module to import from. If None, the attribute
+            is imported from the package itself.
+        package: The name of the package where the module is located.
+    """
+    if module_name == "__module__" or module_name is None:
+        try:
+            result = import_module(f".{attr_name}", package=package)
+        except ModuleNotFoundError:
+            msg = f"module '{package!r}' has no attribute {attr_name!r}"
+            raise AttributeError(msg) from None
+    else:
+        try:
+            module = import_module(f".{module_name}", package=package)
+        except ModuleNotFoundError:
+            msg = f"module '{package!r}.{module_name!r}' not found"
+            raise ImportError(msg) from None
+        result = getattr(module, attr_name)
+    return result

langflow/components/aiml/__init__.py

@@ -1,7 +1,37 @@
-from .aiml import AIMLModelComponent
-from .aiml_embeddings import AIMLEmbeddingsComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components.aiml.aiml import AIMLModelComponent
+    from langflow.components.aiml.aiml_embeddings import AIMLEmbeddingsComponent
+
+_dynamic_imports = {
+    "AIMLModelComponent": "aiml",
+    "AIMLEmbeddingsComponent": "aiml_embeddings",
+}
 
 __all__ = [
     "AIMLEmbeddingsComponent",
     "AIMLModelComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import aiml 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/amazon/__init__.py

@@ -1,5 +1,36 @@
-from .amazon_bedrock_embedding import AmazonBedrockEmbeddingsComponent
-from .amazon_bedrock_model import AmazonBedrockComponent
-from .s3_bucket_uploader import S3BucketUploaderComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components.amazon.amazon_bedrock_embedding import AmazonBedrockEmbeddingsComponent
+    from langflow.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
+    from langflow.components.amazon.s3_bucket_uploader import S3BucketUploaderComponent
+
+_dynamic_imports = {
+    "AmazonBedrockEmbeddingsComponent": "amazon_bedrock_embedding",
+    "AmazonBedrockComponent": "amazon_bedrock_model",
+    "S3BucketUploaderComponent": "s3_bucket_uploader",
+}
 
 __all__ = ["AmazonBedrockComponent", "AmazonBedrockEmbeddingsComponent", "S3BucketUploaderComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import amazon 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/anthropic/__init__.py

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

@@ -1,8 +1,23 @@
-from .assemblyai_get_subtitles import AssemblyAIGetSubtitles
-from .assemblyai_lemur import AssemblyAILeMUR
-from .assemblyai_list_transcripts import AssemblyAIListTranscripts
-from .assemblyai_poll_transcript import AssemblyAITranscriptionJobPoller
-from .assemblyai_start_transcript import AssemblyAITranscriptionJobCreator
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .assemblyai_get_subtitles import AssemblyAIGetSubtitles
+    from .assemblyai_lemur import AssemblyAILeMUR
+    from .assemblyai_list_transcripts import AssemblyAIListTranscripts
+    from .assemblyai_poll_transcript import AssemblyAITranscriptionJobPoller
+    from .assemblyai_start_transcript import AssemblyAITranscriptionJobCreator
+
+_dynamic_imports = {
+    "AssemblyAIGetSubtitles": "assemblyai_get_subtitles",
+    "AssemblyAILeMUR": "assemblyai_lemur",
+    "AssemblyAIListTranscripts": "assemblyai_list_transcripts",
+    "AssemblyAITranscriptionJobCreator": "assemblyai_start_transcript",
+    "AssemblyAITranscriptionJobPoller": "assemblyai_poll_transcript",
+}
 
 __all__ = [
     "AssemblyAIGetSubtitles",
@@ -11,3 +26,21 @@ __all__ = [
     "AssemblyAITranscriptionJobCreator",
     "AssemblyAITranscriptionJobPoller",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import assemblyai 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/__init__.py

@@ -1,7 +1,37 @@
-from .azure_openai import AzureChatOpenAIComponent
-from .azure_openai_embeddings import AzureOpenAIEmbeddingsComponent
+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/baidu/__init__.py

@@ -1,3 +1,32 @@
-from .baidu_qianfan_chat import QianfanChatEndpoint
+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/cleanlab/__init__.py

@@ -1,5 +1,40 @@
-from .cleanlab_evaluator import CleanlabEvaluator
-from .cleanlab_rag_evaluator import CleanlabRAGEvaluator
-from .cleanlab_remediator import CleanlabRemediator
+from __future__ import annotations
 
-__all__ = ["CleanlabEvaluator", "CleanlabRAGEvaluator", "CleanlabRemediator"]
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .cleanlab_evaluator import CleanlabEvaluator
+    from .cleanlab_rag_evaluator import CleanlabRAGEvaluator
+    from .cleanlab_remediator import CleanlabRemediator
+
+_dynamic_imports = {
+    "CleanlabEvaluator": "cleanlab_evaluator",
+    "CleanlabRAGEvaluator": "cleanlab_rag_evaluator",
+    "CleanlabRemediator": "cleanlab_remediator",
+}
+
+__all__ = [
+    "CleanlabEvaluator",
+    "CleanlabRAGEvaluator",
+    "CleanlabRemediator",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import cleanlab 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/cloudflare/__init__.py

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

@@ -1,5 +1,40 @@
-from .cohere_embeddings import CohereEmbeddingsComponent
-from .cohere_models import CohereComponent
-from .cohere_rerank import CohereRerankComponent
+from __future__ import annotations
 
-__all__ = ["CohereComponent", "CohereEmbeddingsComponent", "CohereRerankComponent"]
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .cohere_embeddings import CohereEmbeddingsComponent
+    from .cohere_models import CohereComponent
+    from .cohere_rerank import CohereRerankComponent
+
+_dynamic_imports = {
+    "CohereComponent": "cohere_models",
+    "CohereEmbeddingsComponent": "cohere_embeddings",
+    "CohereRerankComponent": "cohere_rerank",
+}
+
+__all__ = [
+    "CohereComponent",
+    "CohereEmbeddingsComponent",
+    "CohereRerankComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import cohere 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__)