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

langflow/components/composio/__init__.py

@@ -1,9 +1,25 @@
-from .composio_api import ComposioAPIComponent
-from .github_composio import ComposioGitHubAPIComponent
-from .gmail_composio import ComposioGmailAPIComponent
-from .googlecalendar_composio import ComposioGoogleCalendarAPIComponent
-from .outlook_composio import ComposioOutlookAPIComponent
-from .slack_composio import ComposioSlackAPIComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .composio_api import ComposioAPIComponent
+    from .github_composio import ComposioGitHubAPIComponent
+    from .gmail_composio import ComposioGmailAPIComponent
+    from .googlecalendar_composio import ComposioGoogleCalendarAPIComponent
+    from .outlook_composio import ComposioOutlookAPIComponent
+    from .slack_composio import ComposioSlackAPIComponent
+
+_dynamic_imports = {
+    "ComposioAPIComponent": "composio_api",
+    "ComposioGitHubAPIComponent": "github_composio",
+    "ComposioGmailAPIComponent": "gmail_composio",
+    "ComposioGoogleCalendarAPIComponent": "googlecalendar_composio",
+    "ComposioOutlookAPIComponent": "outlook_composio",
+    "ComposioSlackAPIComponent": "slack_composio",
+}
 
 __all__ = [
     "ComposioAPIComponent",
@@ -13,3 +29,21 @@ __all__ = [
     "ComposioOutlookAPIComponent",
     "ComposioSlackAPIComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import composio 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/crewai/__init__.py

@@ -1,9 +1,25 @@
-from .crewai import CrewAIAgentComponent
-from .hierarchical_crew import HierarchicalCrewComponent
-from .hierarchical_task import HierarchicalTaskComponent
-from .sequential_crew import SequentialCrewComponent
-from .sequential_task import SequentialTaskComponent
-from .sequential_task_agent import SequentialTaskAgentComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .crewai import CrewAIAgentComponent
+    from .hierarchical_crew import HierarchicalCrewComponent
+    from .hierarchical_task import HierarchicalTaskComponent
+    from .sequential_crew import SequentialCrewComponent
+    from .sequential_task import SequentialTaskComponent
+    from .sequential_task_agent import SequentialTaskAgentComponent
+
+_dynamic_imports = {
+    "CrewAIAgentComponent": "crewai",
+    "HierarchicalCrewComponent": "hierarchical_crew",
+    "HierarchicalTaskComponent": "hierarchical_task",
+    "SequentialCrewComponent": "sequential_crew",
+    "SequentialTaskAgentComponent": "sequential_task_agent",
+    "SequentialTaskComponent": "sequential_task",
+}
 
 __all__ = [
     "CrewAIAgentComponent",
@@ -13,3 +29,21 @@ __all__ = [
     "SequentialTaskAgentComponent",
     "SequentialTaskComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import crewai 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/custom_component/__init__.py

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

@@ -1,16 +1,39 @@
-from .astra_assistant_manager import AstraAssistantManager
-from .astra_db import AstraDBChatMemory
-from .astra_vectorize import AstraVectorizeComponent
-from .astradb_cql import AstraDBCQLToolComponent
-from .astradb_tool import AstraDBToolComponent
-from .cassandra import CassandraChatMemory
-from .create_assistant import AssistantsCreateAssistant
-from .create_thread import AssistantsCreateThread
-from .dotenv import Dotenv
-from .get_assistant import AssistantsGetAssistantName
-from .getenvvar import GetEnvVar
-from .list_assistants import AssistantsListAssistants
-from .run import AssistantsRun
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .astra_assistant_manager import AstraAssistantManager
+    from .astra_db import AstraDBChatMemory
+    from .astra_vectorize import AstraVectorizeComponent
+    from .astradb_cql import AstraDBCQLToolComponent
+    from .astradb_tool import AstraDBToolComponent
+    from .cassandra import CassandraChatMemory
+    from .create_assistant import AssistantsCreateAssistant
+    from .create_thread import AssistantsCreateThread
+    from .dotenv import Dotenv
+    from .get_assistant import AssistantsGetAssistantName
+    from .getenvvar import GetEnvVar
+    from .list_assistants import AssistantsListAssistants
+    from .run import AssistantsRun
+
+_dynamic_imports = {
+    "AssistantsCreateAssistant": "create_assistant",
+    "AssistantsCreateThread": "create_thread",
+    "AssistantsGetAssistantName": "get_assistant",
+    "AssistantsListAssistants": "list_assistants",
+    "AssistantsRun": "run",
+    "AstraAssistantManager": "astra_assistant_manager",
+    "AstraDBCQLToolComponent": "astradb_cql",
+    "AstraDBChatMemory": "astra_db",
+    "AstraDBToolComponent": "astradb_tool",
+    "AstraVectorizeComponent": "astra_vectorize",
+    "CassandraChatMemory": "cassandra",
+    "Dotenv": "dotenv",
+    "GetEnvVar": "getenvvar",
+}
 
 __all__ = [
     "AssistantsCreateAssistant",
@@ -27,3 +50,21 @@ __all__ = [
     "Dotenv",
     "GetEnvVar",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import datastax 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/deepseek/__init__.py

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

@@ -1,7 +1,21 @@
-from .chunk_docling_document import ChunkDoclingDocumentComponent
-from .docling_inline import DoclingInlineComponent
-from .docling_remote import DoclingRemoteComponent
-from .export_docling_document import ExportDoclingDocumentComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .chunk_docling_document import ChunkDoclingDocumentComponent
+    from .docling_inline import DoclingInlineComponent
+    from .docling_remote import DoclingRemoteComponent
+    from .export_docling_document import ExportDoclingDocumentComponent
+
+_dynamic_imports = {
+    "ChunkDoclingDocumentComponent": "chunk_docling_document",
+    "DoclingInlineComponent": "docling_inline",
+    "DoclingRemoteComponent": "docling_remote",
+    "ExportDoclingDocumentComponent": "export_docling_document",
+}
 
 __all__ = [
     "ChunkDoclingDocumentComponent",
@@ -9,3 +23,21 @@ __all__ = [
     "DoclingRemoteComponent",
     "ExportDoclingDocumentComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import docling 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/embeddings/__init__.py

@@ -1,9 +1,37 @@
-from .similarity import EmbeddingSimilarityComponent
-from .text_embedder import TextEmbedderComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components.embeddings.similarity import EmbeddingSimilarityComponent
+    from langflow.components.embeddings.text_embedder import TextEmbedderComponent
+
+_dynamic_imports = {
+    "EmbeddingSimilarityComponent": "similarity",
+    "TextEmbedderComponent": "text_embedder",
+}
 
 __all__ = [
-    "CloudflareWorkersAIEmbeddingsComponent",
     "EmbeddingSimilarityComponent",
-    "MistralAIEmbeddingsComponent",
     "TextEmbedderComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import embedding 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/firecrawl/__init__.py

@@ -1,6 +1,43 @@
-from .firecrawl_crawl_api import FirecrawlCrawlApi
-from .firecrawl_extract_api import FirecrawlExtractApi
-from .firecrawl_map_api import FirecrawlMapApi
-from .firecrawl_scrape_api import FirecrawlScrapeApi
+from __future__ import annotations
 
-__all__ = ["FirecrawlCrawlApi", "FirecrawlExtractApi", "FirecrawlMapApi", "FirecrawlScrapeApi"]
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .firecrawl_crawl_api import FirecrawlCrawlApi
+    from .firecrawl_extract_api import FirecrawlExtractApi
+    from .firecrawl_map_api import FirecrawlMapApi
+    from .firecrawl_scrape_api import FirecrawlScrapeApi
+
+_dynamic_imports = {
+    "FirecrawlCrawlApi": "firecrawl_crawl_api",
+    "FirecrawlExtractApi": "firecrawl_extract_api",
+    "FirecrawlMapApi": "firecrawl_map_api",
+    "FirecrawlScrapeApi": "firecrawl_scrape_api",
+}
+
+__all__ = [
+    "FirecrawlCrawlApi",
+    "FirecrawlExtractApi",
+    "FirecrawlMapApi",
+    "FirecrawlScrapeApi",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import firecrawl 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/groq/__init__.py

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

@@ -1,10 +1,27 @@
-from .calculator_core import CalculatorComponent
-from .create_list import CreateListComponent
-from .current_date import CurrentDateComponent
-from .id_generator import IDGeneratorComponent
-from .memory import MemoryComponent
-from .output_parser import OutputParserComponent
-from .store_message import MessageStoreComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components.helpers.calculator_core import CalculatorComponent
+    from langflow.components.helpers.create_list import CreateListComponent
+    from langflow.components.helpers.current_date import CurrentDateComponent
+    from langflow.components.helpers.id_generator import IDGeneratorComponent
+    from langflow.components.helpers.memory import MemoryComponent
+    from langflow.components.helpers.output_parser import OutputParserComponent
+    from langflow.components.helpers.store_message import MessageStoreComponent
+
+_dynamic_imports = {
+    "CalculatorComponent": "calculator_core",
+    "CreateListComponent": "create_list",
+    "CurrentDateComponent": "current_date",
+    "IDGeneratorComponent": "id_generator",
+    "MemoryComponent": "memory",
+    "OutputParserComponent": "output_parser",
+    "MessageStoreComponent": "store_message",
+}
 
 __all__ = [
     "CalculatorComponent",
@@ -15,3 +32,21 @@ __all__ = [
     "MessageStoreComponent",
     "OutputParserComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import helper 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/huggingface/__init__.py

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

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

@@ -1,6 +1,38 @@
-from .chat import ChatInput
-from .chat_output import ChatOutput
-from .text import TextInputComponent
-from .text_output import TextOutputComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components.input_output.chat import ChatInput
+    from langflow.components.input_output.chat_output import ChatOutput
+    from langflow.components.input_output.text import TextInputComponent
+    from langflow.components.input_output.text_output import TextOutputComponent
+
+_dynamic_imports = {
+    "ChatInput": "chat",
+    "ChatOutput": "chat_output",
+    "TextInputComponent": "text",
+    "TextOutputComponent": "text_output",
+}
 
 __all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import input/output 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__)