lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/components/data/__init__.py

@@ -1,34 +1,28 @@
+"""Data module - backwards compatibility alias for data_source.
+
+This module provides backwards compatibility by forwarding all imports
+to data_source where the actual data components are located.
+"""
+
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from lfx.components._importing import import_mod
 
-if TYPE_CHECKING:
-    from lfx.components.data.api_request import APIRequestComponent
-    from lfx.components.data.csv_to_data import CSVToDataComponent
-    from lfx.components.data.directory import DirectoryComponent
-    from lfx.components.data.file import FileComponent
-    from lfx.components.data.json_to_data import JSONToDataComponent
-    from lfx.components.data.news_search import NewsSearchComponent
-    from lfx.components.data.rss import RSSReaderComponent
-    from lfx.components.data.sql_executor import SQLComponent
-    from lfx.components.data.url import URLComponent
-    from lfx.components.data.web_search import WebSearchComponent
-    from lfx.components.data.webhook import WebhookComponent
-
+# Replicate the same dynamic imports as data_source
 _dynamic_imports = {
     "APIRequestComponent": "api_request",
     "CSVToDataComponent": "csv_to_data",
-    "DirectoryComponent": "directory",
-    "FileComponent": "file",
     "JSONToDataComponent": "json_to_data",
-    "SQLComponent": "sql_executor",
-    "URLComponent": "url",
-    "WebSearchComponent": "web_search",
-    "WebhookComponent": "webhook",
+    "MockDataGeneratorComponent": "mock_data",
     "NewsSearchComponent": "news_search",
     "RSSReaderComponent": "rss",
+    "URLComponent": "url",
+    "WebSearchComponent": "web_search",
+    # File and Directory components are in files_and_knowledge, forward them for backwards compatibility
+    "FileComponent": ("file", "files_and_knowledge"),
+    "DirectoryComponent": ("directory", "files_and_knowledge"),
 }
 
 __all__ = [
@@ -37,28 +31,84 @@ __all__ = [
     "DirectoryComponent",
     "FileComponent",
     "JSONToDataComponent",
+    "MockDataGeneratorComponent",
     "NewsSearchComponent",
     "RSSReaderComponent",
-    "SQLComponent",
     "URLComponent",
     "WebSearchComponent",
-    "WebhookComponent",
 ]
 
 
 def __getattr__(attr_name: str) -> Any:
-    """Lazily import data components on attribute access."""
+    """Forward attribute access to data_source components."""
+    # Handle submodule access for backwards compatibility
+    # e.g., lfx.components.data.directory -> lfx.components.files_and_knowledge.directory
+    if attr_name == "directory":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.directory")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "file":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.file")
+        globals()[attr_name] = result
+        return result
+    # Data source components were moved to data_source
+    if attr_name == "news_search":
+        from importlib import import_module
+
+        result = import_module("lfx.components.data_source.news_search")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "rss":
+        from importlib import import_module
+
+        result = import_module("lfx.components.data_source.rss")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "web_search":
+        from importlib import import_module
+
+        result = import_module("lfx.components.data_source.web_search")
+        globals()[attr_name] = result
+        return result
+    # SQLComponent was moved to utilities
+    if attr_name == "sql_executor":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.sql_executor")
+        globals()[attr_name] = result
+        return result
+
     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
+
+    mapping = _dynamic_imports[attr_name]
+
+    # Handle FileComponent and DirectoryComponent which are in files_and_knowledge
+    if isinstance(mapping, tuple):
+        module_name, package = mapping
+        try:
+            result = import_mod(attr_name, module_name, f"lfx.components.{package}")
+        except (ModuleNotFoundError, ImportError, AttributeError) as e:
+            msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+            raise AttributeError(msg) from e
+    else:
+        # Import from data_source using the correct package path
+        package = "lfx.components.data_source"
+        try:
+            result = import_mod(attr_name, mapping, package)
+        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 directory of available components."""
     return list(__all__)

lfx/components/data_source/__init__.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.data_source.api_request import APIRequestComponent
+    from lfx.components.data_source.csv_to_data import CSVToDataComponent
+    from lfx.components.data_source.json_to_data import JSONToDataComponent
+    from lfx.components.data_source.mock_data import MockDataGeneratorComponent
+    from lfx.components.data_source.news_search import NewsSearchComponent
+    from lfx.components.data_source.rss import RSSReaderComponent
+    from lfx.components.data_source.sql_executor import SQLComponent
+    from lfx.components.data_source.url import URLComponent
+    from lfx.components.data_source.web_search import WebSearchComponent
+
+_dynamic_imports = {
+    "APIRequestComponent": "api_request",
+    "CSVToDataComponent": "csv_to_data",
+    "JSONToDataComponent": "json_to_data",
+    "MockDataGeneratorComponent": "mock_data",
+    "NewsSearchComponent": "news_search",
+    "RSSReaderComponent": "rss",
+    "URLComponent": "url",
+    "WebSearchComponent": "web_search",
+    "SQLComponent": "sql_executor",
+}
+
+__all__ = [
+    "APIRequestComponent",
+    "CSVToDataComponent",
+    "JSONToDataComponent",
+    "MockDataGeneratorComponent",
+    "NewsSearchComponent",
+    "RSSReaderComponent",
+    "SQLComponent",
+    "URLComponent",
+    "WebSearchComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import data source 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/{data → data_source}/api_request.py

@@ -27,6 +27,7 @@ from lfx.io import (
 from lfx.schema.data import Data
 from lfx.schema.dotdict import dotdict
 from lfx.utils.component_utils import set_current_fields, set_field_advanced, set_field_display
+from lfx.utils.ssrf_protection import SSRFProtectionError, validate_url_for_ssrf
 
 # Define fields for each mode
 MODE_FIELDS = {
@@ -44,7 +45,7 @@ DEFAULT_FIELDS = ["mode"]
 class APIRequestComponent(Component):
     display_name = "API Request"
     description = "Make HTTP requests using URL or cURL commands."
-    documentation: str = "https://docs.langflow.org/components-data#api-request"
+    documentation: str = "https://docs.langflow.org/api-request"
     icon = "Globe"
     name = "APIRequest"
 
@@ -145,8 +146,13 @@ class APIRequestComponent(Component):
         BoolInput(
             name="follow_redirects",
             display_name="Follow Redirects",
-            value=True,
-            info="Whether to follow http redirects.",
+            value=False,
+            info=(
+                "Whether to follow HTTP redirects. "
+                "WARNING: Enabling redirects may allow SSRF bypass attacks where a public URL "
+                "redirects to internal resources. Only enable if you trust the target server. "
+                "See OWASP SSRF Prevention Cheat Sheet for details."
+            ),
             advanced=True,
         ),
         BoolInput(
@@ -424,6 +430,14 @@ class APIRequestComponent(Component):
         save_to_file = self.save_to_file
         include_httpx_metadata = self.include_httpx_metadata
 
+        # Security warning when redirects are enabled
+        if follow_redirects:
+            self.log(
+                "Security Warning: HTTP redirects are enabled. This may allow SSRF bypass attacks "
+                "where a public URL redirects to internal resources (e.g., cloud metadata endpoints). "
+                "Only enable this if you trust the target server."
+            )
+
         # if self.mode == "cURL" and self.curl_input:
         #     self._build_config = self.parse_curl(self.curl_input, dotdict())
         #     # After parsing curl, get the normalized URL
@@ -437,6 +451,15 @@ class APIRequestComponent(Component):
             msg = f"Invalid URL provided: {url}"
             raise ValueError(msg)
 
+        # SSRF Protection: Validate URL to prevent access to internal resources
+        # TODO: In next major version (2.0), remove warn_only=True to enforce blocking
+        try:
+            validate_url_for_ssrf(url, warn_only=True)
+        except SSRFProtectionError as e:
+            # This will only raise if SSRF protection is enabled and warn_only=False
+            msg = f"SSRF Protection: {e}"
+            raise ValueError(msg) from e
+
         # Process query parameters
         if isinstance(self.query_params, str):
             query_params = dict(parse_qsl(self.query_params))

lfx/components/{data → data_source}/csv_to_data.py

@@ -2,9 +2,11 @@ import csv
 import io
 from pathlib import Path
 
+from lfx.base.data.storage_utils import read_file_text
 from lfx.custom.custom_component.component import Component
 from lfx.io import FileInput, MessageTextInput, MultilineInput, Output
 from lfx.schema.data import Data
+from lfx.utils.async_helpers import run_until_complete
 
 
 class CSVToDataComponent(Component):
@@ -52,21 +54,24 @@ class CSVToDataComponent(Component):
         csv_data = None
         try:
             if self.csv_file:
-                resolved_path = self.resolve_path(self.csv_file)
-                file_path = Path(resolved_path)
-                if file_path.suffix.lower() != ".csv":
+                # FileInput always provides a local file path
+                file_path = self.csv_file
+                if not file_path.lower().endswith(".csv"):
                     self.status = "The provided file must be a CSV file."
                 else:
-                    with file_path.open(newline="", encoding="utf-8") as csvfile:
-                        csv_data = csvfile.read()
+                    # Resolve to absolute path and read from local filesystem
+                    resolved_path = self.resolve_path(file_path)
+                    csv_bytes = Path(resolved_path).read_bytes()
+                    csv_data = csv_bytes.decode("utf-8")
 
             elif self.csv_path:
-                file_path = Path(self.csv_path)
-                if file_path.suffix.lower() != ".csv":
-                    self.status = "The provided file must be a CSV file."
+                file_path = self.csv_path
+                if not file_path.lower().endswith(".csv"):
+                    self.status = "The provided path must be to a CSV file."
                 else:
-                    with file_path.open(newline="", encoding="utf-8") as csvfile:
-                        csv_data = csvfile.read()
+                    csv_data = run_until_complete(
+                        read_file_text(file_path, encoding="utf-8", resolve_path=self.resolve_path, newline="")
+                    )
 
             else:
                 csv_data = self.csv_string

lfx/components/{data → data_source}/json_to_data.py

@@ -3,9 +3,11 @@ from pathlib import Path
 
 from json_repair import repair_json
 
+from lfx.base.data.storage_utils import read_file_text
 from lfx.custom.custom_component.component import Component
 from lfx.io import FileInput, MessageTextInput, MultilineInput, Output
 from lfx.schema.data import Data
+from lfx.utils.async_helpers import run_until_complete
 
 
 class JSONToDataComponent(Component):
@@ -51,19 +53,24 @@ class JSONToDataComponent(Component):
 
         try:
             if self.json_file:
-                resolved_path = self.resolve_path(self.json_file)
-                file_path = Path(resolved_path)
-                if file_path.suffix.lower() != ".json":
+                # FileInput always provides a local file path
+                file_path = self.json_file
+                if not file_path.lower().endswith(".json"):
                     self.status = "The provided file must be a JSON file."
                 else:
-                    json_data = file_path.read_text(encoding="utf-8")
+                    # Resolve to absolute path and read from local filesystem
+                    resolved_path = self.resolve_path(file_path)
+                    json_data = Path(resolved_path).read_text(encoding="utf-8")
 
             elif self.json_path:
-                file_path = Path(self.json_path)
-                if file_path.suffix.lower() != ".json":
-                    self.status = "The provided file must be a JSON file."
+                # User-provided text path - could be local or S3 key
+                file_path = self.json_path
+                if not file_path.lower().endswith(".json"):
+                    self.status = "The provided path must be to a JSON file."
                 else:
-                    json_data = file_path.read_text(encoding="utf-8")
+                    json_data = run_until_complete(
+                        read_file_text(file_path, encoding="utf-8", resolve_path=self.resolve_path)
+                    )
 
             else:
                 json_data = self.json_string

lfx/components/{data → data_source}/news_search.py

@@ -12,7 +12,7 @@ from lfx.schema import DataFrame
 class NewsSearchComponent(Component):
     display_name = "News Search"
     description = "Searches Google News via RSS. Returns clean article data."
-    documentation: str = "https://docs.langflow.org/components-data#news-search"
+    documentation: str = "https://docs.langflow.org/web-search"
     icon = "newspaper"
     name = "NewsSearch"
     legacy = True

lfx/components/{data → data_source}/rss.py

@@ -11,7 +11,7 @@ from lfx.schema import DataFrame
 class RSSReaderComponent(Component):
     display_name = "RSS Reader"
     description = "Fetches and parses an RSS feed."
-    documentation: str = "https://docs.langflow.org/components-data#rss-reader"
+    documentation: str = "https://docs.langflow.org/web-search"
     icon = "rss"
     name = "RSSReaderSimple"
     legacy = True

lfx/components/{data → data_source}/sql_executor.py

@@ -18,7 +18,7 @@ class SQLComponent(ComponentWithCache):
 
     display_name = "SQL Database"
     description = "Executes SQL queries on SQLAlchemy-compatible databases."
-    documentation: str = "https://docs.langflow.org/components-data#sql-database"
+    documentation: str = "https://docs.langflow.org/sql-database"
     icon = "database"
     name = "SQLComponent"
     metadata = {"keywords": ["sql", "database", "query", "db", "fetch"]}

lfx/components/{data → data_source}/url.py

@@ -48,7 +48,7 @@ class URLComponent(Component):
 
     display_name = "URL"
     description = "Fetch content from one or more web pages, following links recursively."
-    documentation: str = "https://docs.langflow.org/components-data#url"
+    documentation: str = "https://docs.langflow.org/url"
     icon = "layout-template"
     name = "URLComponent"
 

lfx/components/{data → data_source}/web_search.py

@@ -21,7 +21,7 @@ from lfx.utils.request_utils import get_user_agent
 class WebSearchComponent(Component):
     display_name = "Web Search"
     description = "Search the web, news, or RSS feeds."
-    documentation: str = "https://docs.langflow.org/components-data#web-search"
+    documentation: str = "https://docs.langflow.org/web-search"
     icon = "search"
     name = "UnifiedWebSearch"
 

lfx/components/datastax/__init__.py

@@ -5,17 +5,19 @@ from typing import TYPE_CHECKING, Any
 from lfx.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_assistant_manager import AstraAssistantManager
+    from .astradb_chatmemory import AstraDBChatMemory
     from .astradb_cql import AstraDBCQLToolComponent
+    from .astradb_graph import AstraDBGraphVectorStoreComponent
     from .astradb_tool import AstraDBToolComponent
+    from .astradb_vectorize import AstraVectorizeComponent
     from .astradb_vectorstore import AstraDBVectorStoreComponent
     from .create_assistant import AssistantsCreateAssistant
     from .create_thread import AssistantsCreateThread
     from .dotenv import Dotenv
     from .get_assistant import AssistantsGetAssistantName
     from .getenvvar import GetEnvVar
+    from .graph_rag import GraphRAGComponent
     from .list_assistants import AssistantsListAssistants
     from .run import AssistantsRun
 
@@ -25,14 +27,16 @@ _dynamic_imports = {
     "AssistantsGetAssistantName": "get_assistant",
     "AssistantsListAssistants": "list_assistants",
     "AssistantsRun": "run",
-    "AstraAssistantManager": "astra_assistant_manager",
+    "AstraAssistantManager": "astradb_assistant_manager",
     "AstraDBCQLToolComponent": "astradb_cql",
-    "AstraDBChatMemory": "astra_db",
+    "AstraDBChatMemory": "astradb_chatmemory",
+    "AstraDBGraphVectorStoreComponent": "astradb_graph",
     "AstraDBToolComponent": "astradb_tool",
     "AstraDBVectorStoreComponent": "astradb_vectorstore",
-    "AstraVectorizeComponent": "astra_vectorize",
+    "AstraVectorizeComponent": "astradb_vectorize",
     "Dotenv": "dotenv",
     "GetEnvVar": "getenvvar",
+    "GraphRAGComponent": "graph_rag",
 }
 
 __all__ = [
@@ -44,11 +48,13 @@ __all__ = [
     "AstraAssistantManager",
     "AstraDBCQLToolComponent",
     "AstraDBChatMemory",
+    "AstraDBGraphVectorStoreComponent",
     "AstraDBToolComponent",
     "AstraDBVectorStoreComponent",
     "AstraVectorizeComponent",
     "Dotenv",
     "GetEnvVar",
+    "GraphRAGComponent",
 ]
 
 

lfx/components/datastax/{astra_assistant_manager.py → astradb_assistant_manager.py}

@@ -30,6 +30,7 @@ class AstraAssistantManager(ComponentWithCache):
     name = "Astra Assistant Agent"
     description = "Manages Assistant Interactions"
     icon = "AstraDB"
+    legacy = True
 
     inputs = [
         DropdownInput(

lfx/components/datastax/astradb_chatmemory.py

@@ -0,0 +1,40 @@
+from lfx.base.datastax.astradb_base import AstraDBBaseComponent
+from lfx.base.memory.model import LCChatMemoryComponent
+from lfx.field_typing.constants import Memory
+from lfx.inputs.inputs import MessageTextInput
+
+
+class AstraDBChatMemory(AstraDBBaseComponent, LCChatMemoryComponent):
+    display_name = "Astra DB Chat Memory"
+    description = "Retrieves and stores chat messages from Astra DB."
+    name = "AstraDBChatMemory"
+    icon: str = "AstraDB"
+
+    inputs = [
+        *AstraDBBaseComponent.inputs,
+        MessageTextInput(
+            name="session_id",
+            display_name="Session ID",
+            info="The session ID of the chat. If empty, the current session ID parameter will be used.",
+            advanced=True,
+        ),
+    ]
+
+    def build_message_history(self) -> Memory:
+        try:
+            from langchain_astradb.chat_message_histories import AstraDBChatMessageHistory
+        except ImportError as e:
+            msg = (
+                "Could not import langchain Astra DB integration package. "
+                "Please install it with `uv pip install langchain-astradb`."
+            )
+            raise ImportError(msg) from e
+
+        return AstraDBChatMessageHistory(
+            session_id=self.session_id,
+            collection_name=self.collection_name,
+            token=self.token,
+            api_endpoint=self.get_api_endpoint(),
+            namespace=self.get_keyspace(),
+            environment=self.environment,
+        )

lfx/components/datastax/astradb_cql.py

@@ -8,20 +8,22 @@ import requests
 from langchain_core.tools import StructuredTool, Tool
 from pydantic import BaseModel, Field, create_model
 
+from lfx.base.datastax.astradb_base import AstraDBBaseComponent
 from lfx.base.langchain_utilities.model import LCToolComponent
-from lfx.io import DictInput, IntInput, SecretStrInput, StrInput, TableInput
+from lfx.io import DictInput, IntInput, StrInput, TableInput
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.table import EditMode
 
 
-class AstraDBCQLToolComponent(LCToolComponent):
+class AstraDBCQLToolComponent(AstraDBBaseComponent, LCToolComponent):
     display_name: str = "Astra DB CQL"
     description: str = "Create a tool to get transactional data from DataStax Astra DB CQL Table"
-    documentation: str = "https://docs.langflow.org/bundles-datastax#astra-db-cql"
+    documentation: str = "https://docs.langflow.org/bundles-datastax"
     icon: str = "AstraDB"
 
     inputs = [
+        *AstraDBBaseComponent.inputs,
         StrInput(name="tool_name", display_name="Tool Name", info="The name of the tool.", required=True),
         StrInput(
             name="tool_description",
@@ -29,34 +31,6 @@ class AstraDBCQLToolComponent(LCToolComponent):
             info="The tool description to be passed to the model.",
             required=True,
         ),
-        StrInput(
-            name="keyspace",
-            display_name="Keyspace",
-            value="default_keyspace",
-            info="The keyspace name within Astra DB where the data is stored.",
-            required=True,
-            advanced=True,
-        ),
-        StrInput(
-            name="table_name",
-            display_name="Table Name",
-            info="The name of the table within Astra DB where the data is stored.",
-            required=True,
-        ),
-        SecretStrInput(
-            name="token",
-            display_name="Astra DB Application Token",
-            info="Authentication token for accessing Astra DB.",
-            value="ASTRA_DB_APPLICATION_TOKEN",
-            required=True,
-        ),
-        StrInput(
-            name="api_endpoint",
-            display_name="API Endpoint",
-            info="API endpoint URL for the Astra DB service.",
-            value="ASTRA_DB_API_ENDPOINT",
-            required=True,
-        ),
         StrInput(
             name="projection_fields",
             display_name="Projection fields",
@@ -204,7 +178,7 @@ class AstraDBCQLToolComponent(LCToolComponent):
 
     def astra_rest(self, args):
         headers = {"Accept": "application/json", "X-Cassandra-Token": f"{self.token}"}
-        astra_url = f"{self.api_endpoint}/api/rest/v2/keyspaces/{self.keyspace}/{self.table_name}/"
+        astra_url = f"{self.get_api_endpoint()}/api/rest/v2/keyspaces/{self.get_keyspace()}/{self.collection_name}/"
         where = {}
 
         for param in self.tools_params: