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

lfx/components/__init__.py

@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    # These imports are only for type checking and match _dynamic_imports
+    from lfx.components import (
+        FAISS,
+        Notion,
+        agentql,
+        agents,
+        aiml,
+        amazon,
+        anthropic,
+        apify,
+        arxiv,
+        assemblyai,
+        azure,
+        baidu,
+        bing,
+        cassandra,
+        chains,
+        chroma,
+        cleanlab,
+        clickhouse,
+        cloudflare,
+        cohere,
+        composio,
+        confluence,
+        couchbase,
+        crewai,
+        custom_component,
+        data,
+        datastax,
+        deactivated,
+        deepseek,
+        docling,
+        documentloaders,
+        duckduckgo,
+        elastic,
+        embeddings,
+        exa,
+        firecrawl,
+        git,
+        glean,
+        google,
+        groq,
+        helpers,
+        homeassistant,
+        huggingface,
+        ibm,
+        icosacomputing,
+        input_output,
+        jigsawstack,
+        langchain_utilities,
+        langwatch,
+        link_extractors,
+        lmstudio,
+        logic,
+        maritalk,
+        mem0,
+        milvus,
+        mistral,
+        models,
+        mongodb,
+        needle,
+        notdiamond,
+        novita,
+        nvidia,
+        olivya,
+        ollama,
+        openai,
+        openrouter,
+        output_parsers,
+        perplexity,
+        pgvector,
+        pinecone,
+        processing,
+        prototypes,
+        qdrant,
+        redis,
+        sambanova,
+        scrapegraph,
+        searchapi,
+        serpapi,
+        supabase,
+        tavily,
+        textsplitters,
+        toolkits,
+        tools,
+        twelvelabs,
+        unstructured,
+        upstash,
+        vectara,
+        vectorstores,
+        vertexai,
+        weaviate,
+        wikipedia,
+        wolframalpha,
+        xai,
+        yahoosearch,
+        youtube,
+        zep,
+    )
+
+
+# Dynamic imports mapping - maps both modules and individual components
+_dynamic_imports = {
+    # Category modules (existing functionality)
+    "agentql": "__module__",
+    "agents": "__module__",
+    "aiml": "__module__",
+    "amazon": "__module__",
+    "anthropic": "__module__",
+    "apify": "__module__",
+    "arxiv": "__module__",
+    "assemblyai": "__module__",
+    "azure": "__module__",
+    "baidu": "__module__",
+    "bing": "__module__",
+    "cassandra": "__module__",
+    "chains": "__module__",
+    "chroma": "__module__",
+    "cleanlab": "__module__",
+    "clickhouse": "__module__",
+    "cloudflare": "__module__",
+    "cohere": "__module__",
+    "composio": "__module__",
+    "confluence": "__module__",
+    "couchbase": "__module__",
+    "crewai": "__module__",
+    "custom_component": "__module__",
+    "data": "__module__",
+    "datastax": "__module__",
+    "deactivated": "__module__",
+    "deepseek": "__module__",
+    "docling": "__module__",
+    "documentloaders": "__module__",
+    "duckduckgo": "__module__",
+    "elastic": "__module__",
+    "embeddings": "__module__",
+    "exa": "__module__",
+    "FAISS": "__module__",
+    "firecrawl": "__module__",
+    "git": "__module__",
+    "glean": "__module__",
+    "google": "__module__",
+    "groq": "__module__",
+    "helpers": "__module__",
+    "homeassistant": "__module__",
+    "huggingface": "__module__",
+    "ibm": "__module__",
+    "icosacomputing": "__module__",
+    "input_output": "__module__",
+    "jigsawstack": "__module__",
+    "langchain_utilities": "__module__",
+    "langwatch": "__module__",
+    "link_extractors": "__module__",
+    "lmstudio": "__module__",
+    "logic": "__module__",
+    "maritalk": "__module__",
+    "mem0": "__module__",
+    "milvus": "__module__",
+    "mistral": "__module__",
+    "models": "__module__",
+    "mongodb": "__module__",
+    "needle": "__module__",
+    "notdiamond": "__module__",
+    "Notion": "__module__",
+    "novita": "__module__",
+    "nvidia": "__module__",
+    "olivya": "__module__",
+    "ollama": "__module__",
+    "openai": "__module__",
+    "openrouter": "__module__",
+    "output_parsers": "__module__",
+    "perplexity": "__module__",
+    "pgvector": "__module__",
+    "pinecone": "__module__",
+    "processing": "__module__",
+    "prototypes": "__module__",
+    "qdrant": "__module__",
+    "redis": "__module__",
+    "sambanova": "__module__",
+    "scrapegraph": "__module__",
+    "searchapi": "__module__",
+    "serpapi": "__module__",
+    "supabase": "__module__",
+    "tavily": "__module__",
+    "textsplitters": "__module__",
+    "toolkits": "__module__",
+    "tools": "__module__",
+    "twelvelabs": "__module__",
+    "unstructured": "__module__",
+    "upstash": "__module__",
+    "vectara": "__module__",
+    "vectorstores": "__module__",
+    "vertexai": "__module__",
+    "weaviate": "__module__",
+    "wikipedia": "__module__",
+    "wolframalpha": "__module__",
+    "xai": "__module__",
+    "yahoosearch": "__module__",
+    "youtube": "__module__",
+    "zep": "__module__",
+}
+
+# Track which modules we've already discovered to avoid re-scanning
+_discovered_modules = set()
+
+
+def _discover_components_from_module(module_name):
+    """Discover individual components from a specific module on-demand."""
+    if module_name in _discovered_modules or module_name == "Notion":
+        return
+
+    try:
+        # Try to import the module and get its dynamic imports
+        module = import_mod(module_name, "__module__", __spec__.parent)
+
+        if hasattr(module, "_dynamic_imports"):
+            # Add each component from this module to our main mapping
+            for comp_name, comp_file in module._dynamic_imports.items():
+                # Create the full path: module_name.comp_file
+                _dynamic_imports[comp_name] = f"{module_name}.{comp_file}"
+                # Note: We don't add component names to __all__ since they are classes, not modules
+                # __all__ should only contain module names, individual components are accessible via __getattr__
+
+        _discovered_modules.add(module_name)
+
+    except (ImportError, AttributeError):
+        # If import fails, mark as discovered to avoid retrying
+        _discovered_modules.add(module_name)
+
+
+# Static base __all__ with module names
+__all__ = [
+    "FAISS",
+    "Notion",
+    "agentql",
+    "agents",
+    "aiml",
+    "amazon",
+    "anthropic",
+    "apify",
+    "arxiv",
+    "assemblyai",
+    "azure",
+    "baidu",
+    "bing",
+    "cassandra",
+    "chains",
+    "chroma",
+    "cleanlab",
+    "clickhouse",
+    "cloudflare",
+    "cohere",
+    "composio",
+    "confluence",
+    "couchbase",
+    "crewai",
+    "custom_component",
+    "data",
+    "datastax",
+    "deactivated",
+    "deepseek",
+    "docling",
+    "documentloaders",
+    "duckduckgo",
+    "elastic",
+    "embeddings",
+    "exa",
+    "firecrawl",
+    "git",
+    "glean",
+    "google",
+    "groq",
+    "helpers",
+    "homeassistant",
+    "huggingface",
+    "ibm",
+    "icosacomputing",
+    "input_output",
+    "jigsawstack",
+    "langchain_utilities",
+    "langwatch",
+    "link_extractors",
+    "lmstudio",
+    "logic",
+    "maritalk",
+    "mem0",
+    "milvus",
+    "mistral",
+    "models",
+    "mongodb",
+    "needle",
+    "notdiamond",
+    "novita",
+    "nvidia",
+    "olivya",
+    "ollama",
+    "openai",
+    "openrouter",
+    "output_parsers",
+    "perplexity",
+    "pgvector",
+    "pinecone",
+    "processing",
+    "prototypes",
+    "qdrant",
+    "redis",
+    "sambanova",
+    "scrapegraph",
+    "searchapi",
+    "serpapi",
+    "supabase",
+    "tavily",
+    "textsplitters",
+    "toolkits",
+    "tools",
+    "twelvelabs",
+    "unstructured",
+    "upstash",
+    "vectara",
+    "vectorstores",
+    "vertexai",
+    "weaviate",
+    "wikipedia",
+    "wolframalpha",
+    "xai",
+    "yahoosearch",
+    "youtube",
+    "zep",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import component modules or individual components on attribute access.
+
+    Supports both:
+    - components.agents (module access)
+    - components.AgentComponent (direct component access)
+
+    Uses on-demand discovery - only scans modules when components are requested.
+    """
+    # First check if we already know about this attribute
+    if attr_name not in _dynamic_imports:
+        # Try to discover components from modules that might have this component
+        # Get all module names we haven't discovered yet
+        undiscovered_modules = [
+            name
+            for name in _dynamic_imports
+            if _dynamic_imports[name] == "__module__" and name not in _discovered_modules and name != "Notion"
+        ]
+
+        # Discover components from undiscovered modules
+        # Try all undiscovered modules until we find the component or exhaust the list
+        for module_name in undiscovered_modules:
+            _discover_components_from_module(module_name)
+            # Check if we found what we're looking for
+            if attr_name in _dynamic_imports:
+                break
+
+    # If still not found, raise AttributeError
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+
+    try:
+        module_path = _dynamic_imports[attr_name]
+
+        if module_path == "__module__":
+            # This is a module import (e.g., components.agents)
+            result = import_mod(attr_name, "__module__", __spec__.parent)
+            # After importing a module, discover its components
+            _discover_components_from_module(attr_name)
+        elif "." in module_path:
+            # This is a component import (e.g., components.AgentComponent -> agents.agent)
+            module_name, component_file = module_path.split(".", 1)
+            # Import the specific component from its module
+            result = import_mod(attr_name, component_file, f"{__spec__.parent}.{module_name}")
+        else:
+            # Fallback to regular import
+            result = import_mod(attr_name, module_path, __spec__.parent)
+
+    except (ImportError, AttributeError) as e:
+        # Check if this is a missing dependency issue by looking at the error message
+        if "No module named" in str(e):
+            # Extract the missing module name and suggest installation
+            import re
+
+            match = re.search(r"No module named '([^']+)'", str(e))
+            if match:
+                missing_module = match.group(1)
+                msg = f"Could not import '{attr_name}' from '{__name__}'. Missing dependency: '{missing_module}'. "
+            else:
+                msg = f"Could not import '{attr_name}' from '{__name__}'. Missing dependencies: {e}"
+        elif "cannot import name" in str(e):
+            msg = f"Could not import '{attr_name}' from '{__name__}'. Import error: {e}"
+        else:
+            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/_importing.py

@@ -0,0 +1,42 @@
+"""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 as e:
+            # Check if this is a missing dependency or a missing module
+            if "No module named" in str(e) and package in str(e):
+                # This is likely a missing module file, not a dependency issue
+                msg = f"module '{package}.{module_name}' not found"
+                raise ImportError(msg) from None
+            # This is likely a missing dependency, let the original error bubble up
+            raise
+        result = getattr(module, attr_name)
+    return result

lfx/components/agentql/__init__.py

@@ -0,0 +1,3 @@
+from .agentql_api import AgentQL
+
+__all__ = ["AgentQL"]

lfx/components/agentql/agentql_api.py

@@ -0,0 +1,151 @@
+import httpx
+
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import BoolInput, DropdownInput, IntInput, MessageTextInput, MultilineInput, Output, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+
+class AgentQL(Component):
+    display_name = "Extract Web Data"
+    description = "Extracts structured data from a web page using an AgentQL query or a Natural Language description."
+    documentation: str = "https://docs.agentql.com/rest-api/api-reference"
+    icon = "AgentQL"
+    name = "AgentQL"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            required=True,
+            password=True,
+            info="Your AgentQL API key from dev.agentql.com",
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            required=True,
+            info="The URL of the public web page you want to extract data from.",
+            tool_mode=True,
+        ),
+        MultilineInput(
+            name="query",
+            display_name="AgentQL Query",
+            required=False,
+            info="The AgentQL query to execute. Learn more at https://docs.agentql.com/agentql-query or use a prompt.",
+            tool_mode=True,
+        ),
+        MultilineInput(
+            name="prompt",
+            display_name="Prompt",
+            required=False,
+            info="A Natural Language description of the data to extract from the page. Alternative to AgentQL query.",
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="is_stealth_mode_enabled",
+            display_name="Enable Stealth Mode (Beta)",
+            info="Enable experimental anti-bot evasion strategies. May not work for all websites at all times.",
+            value=False,
+            advanced=True,
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            info="Seconds to wait for a request.",
+            value=900,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="mode",
+            display_name="Request Mode",
+            info="'standard' uses deep data analysis, while 'fast' trades some depth of analysis for speed.",
+            options=["fast", "standard"],
+            value="fast",
+            advanced=True,
+        ),
+        IntInput(
+            name="wait_for",
+            display_name="Wait For",
+            info="Seconds to wait for the page to load before extracting data.",
+            value=0,
+            range_spec=RangeSpec(min=0, max=10, step_type="int"),
+            advanced=True,
+        ),
+        BoolInput(
+            name="is_scroll_to_bottom_enabled",
+            display_name="Enable scroll to bottom",
+            info="Scroll to bottom of the page before extracting data.",
+            value=False,
+            advanced=True,
+        ),
+        BoolInput(
+            name="is_screenshot_enabled",
+            display_name="Enable screenshot",
+            info="Take a screenshot before extracting data. Returned in 'metadata' as a Base64 string.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="build_output"),
+    ]
+
+    def build_output(self) -> Data:
+        endpoint = "https://api.agentql.com/v1/query-data"
+        headers = {
+            "X-API-Key": self.api_key,
+            "Content-Type": "application/json",
+            "X-TF-Request-Origin": "langflow",
+        }
+
+        payload = {
+            "url": self.url,
+            "query": self.query,
+            "prompt": self.prompt,
+            "params": {
+                "mode": self.mode,
+                "wait_for": self.wait_for,
+                "is_scroll_to_bottom_enabled": self.is_scroll_to_bottom_enabled,
+                "is_screenshot_enabled": self.is_screenshot_enabled,
+            },
+            "metadata": {
+                "experimental_stealth_mode_enabled": self.is_stealth_mode_enabled,
+            },
+        }
+
+        if not self.prompt and not self.query:
+            self.status = "Either Query or Prompt must be provided."
+            raise ValueError(self.status)
+        if self.prompt and self.query:
+            self.status = "Both Query and Prompt can't be provided at the same time."
+            raise ValueError(self.status)
+
+        try:
+            response = httpx.post(endpoint, headers=headers, json=payload, timeout=self.timeout)
+            response.raise_for_status()
+
+            json = response.json()
+            data = Data(result=json["data"], metadata=json["metadata"])
+
+        except httpx.HTTPStatusError as e:
+            response = e.response
+            if response.status_code == httpx.codes.UNAUTHORIZED:
+                self.status = "Please, provide a valid API Key. You can create one at https://dev.agentql.com."
+            else:
+                try:
+                    error_json = response.json()
+                    logger.error(
+                        f"Failure response: '{response.status_code} {response.reason_phrase}' with body: {error_json}"
+                    )
+                    msg = error_json["error_info"] if "error_info" in error_json else error_json["detail"]
+                except (ValueError, TypeError):
+                    msg = f"HTTP {e}."
+                self.status = msg
+            raise ValueError(self.status) from e
+
+        else:
+            self.status = data
+            return data

lfx/components/agents/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.agents.agent import AgentComponent
+    from lfx.components.agents.mcp_component import MCPToolsComponent
+
+_dynamic_imports = {
+    "AgentComponent": "agent",
+    "MCPToolsComponent": "mcp_component",
+}
+
+__all__ = ["AgentComponent", "MCPToolsComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import agent 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__)