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

langflow/components/langchain_utilities/__init__.py

@@ -1,29 +1,65 @@
-from .character import CharacterTextSplitterComponent
-from .conversation import ConversationChainComponent
-from .csv_agent import CSVAgentComponent
-from .fake_embeddings import FakeEmbeddingsComponent
-from .html_link_extractor import HtmlLinkExtractorComponent
-from .json_agent import JsonAgentComponent
-from .langchain_hub import LangChainHubPromptComponent
-from .language_recursive import LanguageRecursiveTextSplitterComponent
-from .language_semantic import SemanticTextSplitterComponent
-from .llm_checker import LLMCheckerChainComponent
-from .llm_math import LLMMathChainComponent
-from .natural_language import NaturalLanguageTextSplitterComponent
-from .openai_tools import OpenAIToolsAgentComponent
-from .openapi import OpenAPIAgentComponent
-from .recursive_character import RecursiveCharacterTextSplitterComponent
-from .retrieval_qa import RetrievalQAComponent
-from .runnable_executor import RunnableExecComponent
-from .self_query import SelfQueryRetrieverComponent
-from .spider import SpiderTool
-from .sql import SQLAgentComponent
-from .sql_database import SQLDatabaseComponent
-from .sql_generator import SQLGeneratorComponent
-from .tool_calling import ToolCallingAgentComponent
-from .vector_store_info import VectorStoreInfoComponent
-from .vector_store_router import VectorStoreRouterAgentComponent
-from .xml_agent import XMLAgentComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .character import CharacterTextSplitterComponent
+    from .conversation import ConversationChainComponent
+    from .csv_agent import CSVAgentComponent
+    from .fake_embeddings import FakeEmbeddingsComponent
+    from .html_link_extractor import HtmlLinkExtractorComponent
+    from .json_agent import JsonAgentComponent
+    from .langchain_hub import LangChainHubPromptComponent
+    from .language_recursive import LanguageRecursiveTextSplitterComponent
+    from .language_semantic import SemanticTextSplitterComponent
+    from .llm_checker import LLMCheckerChainComponent
+    from .llm_math import LLMMathChainComponent
+    from .natural_language import NaturalLanguageTextSplitterComponent
+    from .openai_tools import OpenAIToolsAgentComponent
+    from .openapi import OpenAPIAgentComponent
+    from .recursive_character import RecursiveCharacterTextSplitterComponent
+    from .retrieval_qa import RetrievalQAComponent
+    from .runnable_executor import RunnableExecComponent
+    from .self_query import SelfQueryRetrieverComponent
+    from .spider import SpiderTool
+    from .sql import SQLAgentComponent
+    from .sql_database import SQLDatabaseComponent
+    from .sql_generator import SQLGeneratorComponent
+    from .tool_calling import ToolCallingAgentComponent
+    from .vector_store_info import VectorStoreInfoComponent
+    from .vector_store_router import VectorStoreRouterAgentComponent
+    from .xml_agent import XMLAgentComponent
+
+_dynamic_imports = {
+    "CharacterTextSplitterComponent": "character",
+    "ConversationChainComponent": "conversation",
+    "CSVAgentComponent": "csv_agent",
+    "FakeEmbeddingsComponent": "fake_embeddings",
+    "HtmlLinkExtractorComponent": "html_link_extractor",
+    "JsonAgentComponent": "json_agent",
+    "LangChainHubPromptComponent": "langchain_hub",
+    "LanguageRecursiveTextSplitterComponent": "language_recursive",
+    "LLMCheckerChainComponent": "llm_checker",
+    "LLMMathChainComponent": "llm_math",
+    "NaturalLanguageTextSplitterComponent": "natural_language",
+    "OpenAIToolsAgentComponent": "openai_tools",
+    "OpenAPIAgentComponent": "openapi",
+    "RecursiveCharacterTextSplitterComponent": "recursive_character",
+    "RetrievalQAComponent": "retrieval_qa",
+    "RunnableExecComponent": "runnable_executor",
+    "SelfQueryRetrieverComponent": "self_query",
+    "SemanticTextSplitterComponent": "language_semantic",
+    "SpiderTool": "spider",
+    "SQLAgentComponent": "sql",
+    "SQLDatabaseComponent": "sql_database",
+    "SQLGeneratorComponent": "sql_generator",
+    "ToolCallingAgentComponent": "tool_calling",
+    "VectorStoreInfoComponent": "vector_store_info",
+    "VectorStoreRouterAgentComponent": "vector_store_router",
+    "XMLAgentComponent": "xml_agent",
+}
 
 __all__ = [
     "CSVAgentComponent",
@@ -53,3 +89,21 @@ __all__ = [
     "VectorStoreRouterAgentComponent",
     "XMLAgentComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import langchain utility 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/langchain_utilities/conversation.py

@@ -1,8 +1,8 @@
 from langchain.chains import ConversationChain
 
 from langflow.base.chains.model import LCChainComponent
-from langflow.field_typing import Message
 from langflow.inputs.inputs import HandleInput, MultilineInput
+from langflow.schema.message import Message
 
 
 class ConversationChainComponent(LCChainComponent):

langflow/components/langchain_utilities/llm_checker.py

@@ -1,8 +1,8 @@
 from langchain.chains import LLMCheckerChain
 
 from langflow.base.chains.model import LCChainComponent
-from langflow.field_typing import Message
 from langflow.inputs.inputs import HandleInput, MultilineInput
+from langflow.schema.message import Message
 
 
 class LLMCheckerChainComponent(LCChainComponent):

langflow/components/langchain_utilities/llm_math.py

@@ -1,8 +1,8 @@
 from langchain.chains import LLMMathChain
 
 from langflow.base.chains.model import LCChainComponent
-from langflow.field_typing import Message
 from langflow.inputs.inputs import HandleInput, MultilineInput
+from langflow.schema.message import Message
 from langflow.template.field.base import Output
 
 

langflow/components/langchain_utilities/retrieval_qa.py

@@ -1,8 +1,10 @@
+from typing import cast
+
 from langchain.chains import RetrievalQA
 
 from langflow.base.chains.model import LCChainComponent
-from langflow.field_typing import Message
 from langflow.inputs.inputs import BoolInput, DropdownInput, HandleInput, MultilineInput
+from langflow.schema.message import Message
 
 
 class RetrievalQAComponent(LCChainComponent):
@@ -78,4 +80,4 @@ class RetrievalQAComponent(LCChainComponent):
             result_str = f"{result_str}\n{references_str}"
         # put the entire result to debug history, query and content
         self.status = {**result, "source_documents": source_docs, "output": result_str}
-        return result_str
+        return cast("Message", result_str)

langflow/components/langchain_utilities/sql_generator.py

@@ -4,8 +4,8 @@ from langchain.chains import create_sql_query_chain
 from langchain_core.prompts import PromptTemplate
 
 from langflow.base.chains.model import LCChainComponent
-from langflow.field_typing import Message
 from langflow.inputs.inputs import HandleInput, IntInput, MultilineInput
+from langflow.schema.message import Message
 from langflow.template.field.base import Output
 
 if TYPE_CHECKING:

langflow/components/lmstudio/__init__.py

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

@@ -1,10 +1,27 @@
-from .conditional_router import ConditionalRouterComponent
-from .data_conditional_router import DataConditionalRouterComponent
-from .flow_tool import FlowToolComponent
-from .loop import LoopComponent
-from .pass_message import PassMessageComponent
-from .run_flow import RunFlowComponent
-from .sub_flow import SubFlowComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components.logic.conditional_router import ConditionalRouterComponent
+    from langflow.components.logic.data_conditional_router import DataConditionalRouterComponent
+    from langflow.components.logic.flow_tool import FlowToolComponent
+    from langflow.components.logic.loop import LoopComponent
+    from langflow.components.logic.pass_message import PassMessageComponent
+    from langflow.components.logic.run_flow import RunFlowComponent
+    from langflow.components.logic.sub_flow import SubFlowComponent
+
+_dynamic_imports = {
+    "ConditionalRouterComponent": "conditional_router",
+    "DataConditionalRouterComponent": "data_conditional_router",
+    "FlowToolComponent": "flow_tool",
+    "LoopComponent": "loop",
+    "PassMessageComponent": "pass_message",
+    "RunFlowComponent": "run_flow",
+    "SubFlowComponent": "sub_flow",
+}
 
 __all__ = [
     "ConditionalRouterComponent",
@@ -15,3 +32,21 @@ __all__ = [
     "RunFlowComponent",
     "SubFlowComponent",
 ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import logic 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/maritalk/__init__.py

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

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

@@ -1,4 +1,34 @@
-from .embedding_model import EmbeddingModelComponent
-from .language_model import LanguageModelComponent
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from langflow.components.models.embedding_model import EmbeddingModelComponent
+    from langflow.components.models.language_model import LanguageModelComponent
+
+_dynamic_imports = {
+    "EmbeddingModelComponent": "embedding_model",
+    "LanguageModelComponent": "language_model",
+}
 
 __all__ = ["EmbeddingModelComponent", "LanguageModelComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import model 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/notdiamond/__init__.py

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

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

@@ -1,13 +1,28 @@
+from __future__ import annotations
+
 import sys
+from typing import TYPE_CHECKING, Any
 
-from .nvidia import NVIDIAModelComponent
-from .nvidia_embedding import NVIDIAEmbeddingsComponent
-from .nvidia_ingest import NvidiaIngestComponent
-from .nvidia_rerank import NvidiaRerankComponent
+from langflow.components._importing import import_mod
 
-if sys.platform == "win32":
-    from .system_assist import NvidiaSystemAssistComponent
+if TYPE_CHECKING:
+    from .nvidia import NVIDIAModelComponent
+    from .nvidia_embedding import NVIDIAEmbeddingsComponent
+    from .nvidia_ingest import NvidiaIngestComponent
+    from .nvidia_rerank import NvidiaRerankComponent
+
+    if sys.platform == "win32":
+        from .system_assist import NvidiaSystemAssistComponent
+
+_dynamic_imports = {
+    "NVIDIAModelComponent": "nvidia",
+    "NVIDIAEmbeddingsComponent": "nvidia_embedding",
+    "NvidiaIngestComponent": "nvidia_ingest",
+    "NvidiaRerankComponent": "nvidia_rerank",
+}
 
+if sys.platform == "win32":
+    _dynamic_imports["NvidiaSystemAssistComponent"] = "system_assist"
     __all__ = [
         "NVIDIAEmbeddingsComponent",
         "NVIDIAModelComponent",
@@ -16,4 +31,27 @@ if sys.platform == "win32":
         "NvidiaSystemAssistComponent",
     ]
 else:
-    __all__ = ["NVIDIAEmbeddingsComponent", "NVIDIAModelComponent", "NvidiaIngestComponent", "NvidiaRerankComponent"]
+    __all__ = [
+        "NVIDIAEmbeddingsComponent",
+        "NVIDIAModelComponent",
+        "NvidiaIngestComponent",
+        "NvidiaRerankComponent",
+    ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import nvidia 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/ollama/__init__.py

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

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

@@ -1,3 +1,32 @@
-from .openrouter import OpenRouterComponent
+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/perplexity/__init__.py

@@ -1,3 +1,34 @@
-from .perplexity import PerplexityComponent
+from __future__ import annotations
 
-__all__ = ["PerplexityComponent"]
+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__)