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

lfx/components/processing/__init__.py

@@ -7,98 +7,50 @@ from typing import TYPE_CHECKING, Any
 from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from lfx.components.processing.alter_metadata import AlterMetadataComponent
-    from lfx.components.processing.batch_run import BatchRunComponent
     from lfx.components.processing.combine_text import CombineTextComponent
     from lfx.components.processing.converter import TypeConverterComponent
-    from lfx.components.processing.create_data import CreateDataComponent
+    from lfx.components.processing.create_list import CreateListComponent
     from lfx.components.processing.data_operations import DataOperationsComponent
-    from lfx.components.processing.data_to_dataframe import DataToDataFrameComponent
     from lfx.components.processing.dataframe_operations import DataFrameOperationsComponent
     from lfx.components.processing.dataframe_to_toolset import DataFrameToToolsetComponent
-    from lfx.components.processing.dynamic_create_data import DynamicCreateDataComponent
-    from lfx.components.processing.extract_key import ExtractDataKeyComponent
-    from lfx.components.processing.filter_data import FilterDataComponent
-    from lfx.components.processing.filter_data_values import DataFilterComponent
     from lfx.components.processing.json_cleaner import JSONCleaner
-    from lfx.components.processing.lambda_filter import LambdaFilterComponent
-    from lfx.components.processing.llm_router import LLMRouterComponent
-    from lfx.components.processing.merge_data import MergeDataComponent
-    from lfx.components.processing.message_to_data import MessageToDataComponent
+    from lfx.components.processing.output_parser import OutputParserComponent
     from lfx.components.processing.parse_data import ParseDataComponent
-    from lfx.components.processing.parse_dataframe import ParseDataFrameComponent
-    from lfx.components.processing.parse_json_data import ParseJSONDataComponent
     from lfx.components.processing.parser import ParserComponent
-    from lfx.components.processing.prompt import PromptComponent
-    from lfx.components.processing.python_repl_core import PythonREPLComponent
     from lfx.components.processing.regex import RegexExtractorComponent
-    from lfx.components.processing.select_data import SelectDataComponent
     from lfx.components.processing.split_text import SplitTextComponent
-    from lfx.components.processing.structured_output import StructuredOutputComponent
-    from lfx.components.processing.update_data import UpdateDataComponent
+    from lfx.components.processing.store_message import MessageStoreComponent
 
 _dynamic_imports = {
-    "AlterMetadataComponent": "alter_metadata",
-    "BatchRunComponent": "batch_run",
     "CombineTextComponent": "combine_text",
     "TypeConverterComponent": "converter",
-    "CreateDataComponent": "create_data",
+    "CreateListComponent": "create_list",
     "DataOperationsComponent": "data_operations",
-    "DataToDataFrameComponent": "data_to_dataframe",
     "DataFrameOperationsComponent": "dataframe_operations",
     "DataFrameToToolsetComponent": "dataframe_to_toolset",
-    "DynamicCreateDataComponent": "dynamic_create_data",
-    "ExtractDataKeyComponent": "extract_key",
-    "FilterDataComponent": "filter_data",
-    "DataFilterComponent": "filter_data_values",
     "JSONCleaner": "json_cleaner",
-    "LambdaFilterComponent": "lambda_filter",
-    "LLMRouterComponent": "llm_router",
-    "MergeDataComponent": "merge_data",
-    "MessageToDataComponent": "message_to_data",
+    "OutputParserComponent": "output_parser",
     "ParseDataComponent": "parse_data",
-    "ParseDataFrameComponent": "parse_dataframe",
-    "ParseJSONDataComponent": "parse_json_data",
     "ParserComponent": "parser",
-    "PromptComponent": "prompt",
-    "PythonREPLComponent": "python_repl_core",
     "RegexExtractorComponent": "regex",
-    "SelectDataComponent": "select_data",
     "SplitTextComponent": "split_text",
-    "StructuredOutputComponent": "structured_output",
-    "UpdateDataComponent": "update_data",
+    "MessageStoreComponent": "store_message",
 }
 
 __all__ = [
-    "AlterMetadataComponent",
-    "BatchRunComponent",
     "CombineTextComponent",
-    "CreateDataComponent",
-    "DataFilterComponent",
+    "CreateListComponent",
     "DataFrameOperationsComponent",
     "DataFrameToToolsetComponent",
     "DataOperationsComponent",
-    "DataToDataFrameComponent",
-    "DynamicCreateDataComponent",
-    "ExtractDataKeyComponent",
-    "FilterDataComponent",
     "JSONCleaner",
-    "LLMRouterComponent",
-    "LambdaFilterComponent",
-    "MergeDataComponent",
-    "MessageToDataComponent",
+    "MessageStoreComponent",
+    "OutputParserComponent",
     "ParseDataComponent",
-    "ParseDataFrameComponent",
-    "ParseJSONDataComponent",
     "ParserComponent",
-    "PromptComponent",
-    "PythonREPLComponent",
     "RegexExtractorComponent",
-    "SelectDataComponent",
     "SplitTextComponent",
-    "StructuredOutputComponent",
     "TypeConverterComponent",
-    "UpdateDataComponent",
 ]
 
 

lfx/components/processing/converter.py

@@ -140,7 +140,7 @@ def _parse_csv_to_data(text: str) -> Data:
 class TypeConverterComponent(Component):
     display_name = "Type Convert"
     description = "Convert between different types (Message, Data, DataFrame)"
-    documentation: str = "https://docs.langflow.org/components-processing#type-convert"
+    documentation: str = "https://docs.langflow.org/type-convert"
     icon = "repeat"
 
     inputs = [

lfx/components/processing/dataframe_operations.py

@@ -10,7 +10,7 @@ from lfx.schema.dataframe import DataFrame
 class DataFrameOperationsComponent(Component):
     display_name = "DataFrame Operations"
     description = "Perform various operations on a DataFrame."
-    documentation: str = "https://docs.langflow.org/components-processing#dataframe-operations"
+    documentation: str = "https://docs.langflow.org/dataframe-operations"
     icon = "table"
     name = "DataFrameOperations"
 

lfx/components/processing/parse_json_data.py

@@ -84,8 +84,8 @@ class ParseJSONDataComponent(Component):
 
         full_filter_str = json.dumps(to_filter_as_dict)
 
-        logger.info("to_filter: ", to_filter)
+        logger.info("to_filter: %s", to_filter)
 
         results = jq.compile(self.query).input_text(full_filter_str).all()
-        logger.info("results: ", results)
+        logger.info("results: %s", results)
         return [Data(data=value) if isinstance(value, dict) else Data(text=str(value)) for value in results]

lfx/components/processing/parser.py

@@ -10,7 +10,7 @@ from lfx.template.field.base import Output
 class ParserComponent(Component):
     display_name = "Parser"
     description = "Extracts text using a template."
-    documentation: str = "https://docs.langflow.org/components-processing#parser"
+    documentation: str = "https://docs.langflow.org/parser"
     icon = "braces"
 
     inputs = [
@@ -122,7 +122,12 @@ class ParserComponent(Component):
                 formatted_text = self.pattern.format(**row.to_dict())
                 lines.append(formatted_text)
         elif data is not None:
-            formatted_text = self.pattern.format(**data.data)
+            # Use format_map with a dict that returns default_value for missing keys
+            class DefaultDict(dict):
+                def __missing__(self, key):
+                    return data.default_value or ""
+
+            formatted_text = self.pattern.format_map(DefaultDict(data.data))
             lines.append(formatted_text)
 
         combined_text = self.sep.join(lines)

lfx/components/processing/split_text.py

@@ -11,7 +11,7 @@ from lfx.utils.util import unescape_string
 class SplitTextComponent(Component):
     display_name: str = "Split Text"
     description: str = "Split text into chunks based on specified criteria."
-    documentation: str = "https://docs.langflow.org/components-processing#split-text"
+    documentation: str = "https://docs.langflow.org/split-text"
     icon = "scissors-line-dashed"
     name = "SplitText"
 

lfx/components/qdrant/qdrant.py

@@ -1,5 +1,5 @@
-from langchain.embeddings.base import Embeddings
 from langchain_community.vectorstores import Qdrant
+from langchain_core.embeddings import Embeddings
 
 from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
 from lfx.helpers.data import docs_to_data

lfx/components/redis/redis.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 
-from langchain.text_splitter import CharacterTextSplitter
 from langchain_community.vectorstores.redis import Redis
+from langchain_text_splitters import CharacterTextSplitter
 
 from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
 from lfx.helpers.data import docs_to_data

lfx/components/twelvelabs/split_video.py

@@ -9,6 +9,13 @@ from lfx.custom import Component
 from lfx.inputs import BoolInput, DropdownInput, HandleInput, IntInput
 from lfx.schema import Data
 from lfx.template import Output
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
+
+disable_component_in_astra_cloud_msg = (
+    "Video processing is not supported in Astra cloud environment. "
+    "Video components require local file system access for processing. "
+    "Please use local storage mode or process videos locally before uploading."
+)
 
 
 class SplitVideoComponent(Component):
@@ -267,6 +274,9 @@ class SplitVideoComponent(Component):
 
     def process(self) -> list[Data]:
         """Process the input video and return a list of Data objects containing the clips."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
+
         try:
             # Get the input video path from the previous component
             if not hasattr(self, "videodata") or not isinstance(self.videodata, list) or len(self.videodata) != 1:

lfx/components/twelvelabs/video_file.py

@@ -3,6 +3,13 @@ from pathlib import Path
 from lfx.base.data import BaseFileComponent
 from lfx.io import FileInput
 from lfx.schema import Data, DataFrame
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
+
+disable_component_in_astra_cloud_msg = (
+    "Video processing is not supported in Astra cloud environment. "
+    "Video components require local file system access for processing. "
+    "Please use local storage mode or process videos locally before uploading."
+)
 
 
 class VideoFileComponent(BaseFileComponent):
@@ -97,6 +104,8 @@ class VideoFileComponent(BaseFileComponent):
 
     def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
         """Process video files."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         self.log(f"DEBUG: Processing video files: {len(file_list)}")
 
         if not file_list:
@@ -137,6 +146,9 @@ class VideoFileComponent(BaseFileComponent):
 
     def load_files(self) -> DataFrame:
         """Load video files and return a list of Data objects."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
+
         try:
             self.log("DEBUG: Starting video file load")
             if not hasattr(self, "file_path") or not self.file_path:

lfx/components/utilities/__init__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.utilities.calculator_core import CalculatorComponent
+    from lfx.components.utilities.current_date import CurrentDateComponent
+    from lfx.components.utilities.id_generator import IDGeneratorComponent
+    from lfx.components.utilities.python_repl_core import PythonREPLComponent
+
+_dynamic_imports = {
+    "CalculatorComponent": "calculator_core",
+    "CurrentDateComponent": "current_date",
+    "IDGeneratorComponent": "id_generator",
+    "PythonREPLComponent": "python_repl_core",
+}
+
+__all__ = [
+    "CalculatorComponent",
+    "CurrentDateComponent",
+    "IDGeneratorComponent",
+    "PythonREPLComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import 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__)

lfx/components/{helpers → utilities}/calculator_core.py

@@ -11,7 +11,7 @@ from lfx.schema.data import Data
 class CalculatorComponent(Component):
     display_name = "Calculator"
     description = "Perform basic arithmetic operations on a given expression."
-    documentation: str = "https://docs.langflow.org/components-helpers#calculator"
+    documentation: str = "https://docs.langflow.org/calculator"
     icon = "calculator"
 
     # Cache operators dictionary as a class variable

lfx/components/{helpers → utilities}/current_date.py

@@ -10,7 +10,7 @@ from lfx.schema.message import Message
 class CurrentDateComponent(Component):
     display_name = "Current Date"
     description = "Returns the current date and time in the selected timezone."
-    documentation: str = "https://docs.langflow.org/components-helpers#current-date"
+    documentation: str = "https://docs.langflow.org/current-date"
     icon = "clock"
     name = "CurrentDate"
 

lfx/components/{processing → utilities}/python_repl_core.py

@@ -10,7 +10,7 @@ from lfx.schema.data import Data
 class PythonREPLComponent(Component):
     display_name = "Python Interpreter"
     description = "Run Python code with optional imports. Use print() to see the output."
-    documentation: str = "https://docs.langflow.org/components-processing#python-interpreter"
+    documentation: str = "https://docs.langflow.org/python-interpreter"
     icon = "square-terminal"
 
     inputs = [

lfx/components/vectorstores/__init__.py

@@ -5,20 +5,14 @@ from typing import TYPE_CHECKING, Any
 from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from .astradb import AstraDBVectorStoreComponent
     from .local_db import LocalDBComponent
-    from .mongodb_atlas import MongoVectorStoreComponent
 
 _dynamic_imports = {
     "LocalDBComponent": "local_db",
-    "AstraDBVectorStoreComponent": "astradb",
-    "MongoVectorStoreComponent": "mongodb_atlas",
 }
 
 __all__ = [
-    "AstraDBVectorStoreComponent",
     "LocalDBComponent",
-    "MongoVectorStoreComponent",
 ]
 
 

lfx/components/vectorstores/local_db.py

@@ -12,6 +12,13 @@ from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 from lfx.template.field.base import Output
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
+
+disable_component_in_astra_cloud_msg = (
+    "Local vector stores are not supported in S3/cloud mode. "
+    "Local vector stores require local file system access for persistence. "
+    "Please use cloud-based vector stores (Pinecone, Weaviate, etc.) or local storage mode."
+)
 
 
 class LocalDBComponent(LCVectorStoreComponent):
@@ -193,6 +200,8 @@ class LocalDBComponent(LCVectorStoreComponent):
     @check_cached_vector_store
     def build_vector_store(self) -> Chroma:
         """Builds the Chroma object."""
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
+
         try:
             from langchain_chroma import Chroma
         except ImportError as e:

lfx/components/youtube/youtube_transcripts.py

@@ -1,7 +1,7 @@
+import re
+
 import pandas as pd
-import youtube_transcript_api
-from langchain_community.document_loaders import YoutubeLoader
-from langchain_community.document_loaders.youtube import TranscriptFormat
+from youtube_transcript_api import NoTranscriptFound, TranscriptsDisabled, YouTubeTranscriptApi
 
 from lfx.custom.custom_component.component import Component
 from lfx.inputs.inputs import DropdownInput, IntInput, MultilineInput
@@ -48,43 +48,133 @@ class YouTubeTranscriptsComponent(Component):
         Output(name="data_output", display_name="Transcript + Source", method="get_data_output"),
     ]
 
+    def _extract_video_id(self, url: str) -> str:
+        """Extract video ID from YouTube URL."""
+        patterns = [
+            r"(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([^&\n?#]+)",
+            r"youtube\.com\/watch\?.*?v=([^&\n?#]+)",
+        ]
+        for pattern in patterns:
+            match = re.search(pattern, url)
+            if match:
+                return match.group(1)
+        msg = f"Could not extract video ID from URL: {url}"
+        raise ValueError(msg)
+
     def _load_transcripts(self, *, as_chunks: bool = True):
         """Internal method to load transcripts from YouTube."""
-        loader = YoutubeLoader.from_youtube_url(
-            self.url,
-            transcript_format=TranscriptFormat.CHUNKS if as_chunks else TranscriptFormat.TEXT,
-            chunk_size_seconds=self.chunk_size_seconds,
-            translation=self.translation or None,
-        )
-        return loader.load()
+        try:
+            video_id = self._extract_video_id(self.url)
+        except ValueError as e:
+            msg = f"Invalid YouTube URL: {e}"
+            raise ValueError(msg) from e
+
+        try:
+            # Use new v1.0+ API - create instance
+            api = YouTubeTranscriptApi()
+            transcript_list = api.list(video_id)
+
+            # Get transcript in specified language or default to English
+            if self.translation:
+                # Get any available transcript and translate it
+                transcript = transcript_list.find_transcript(["en"])
+                transcript = transcript.translate(self.translation)
+            else:
+                # Try to get transcript in available languages
+                try:
+                    transcript = transcript_list.find_transcript(["en"])
+                except NoTranscriptFound:
+                    # Try auto-generated English
+                    transcript = transcript_list.find_generated_transcript(["en"])
+
+            # Fetch the transcript data
+            transcript_data = api.fetch(transcript.video_id, [transcript.language_code])
+
+        except (TranscriptsDisabled, NoTranscriptFound) as e:
+            error_type = type(e).__name__
+            msg = (
+                f"Could not retrieve transcripts for video '{video_id}'. "
+                "Possible reasons:\n"
+                "1. This video does not have captions/transcripts enabled\n"
+                "2. The video is private, restricted, or deleted\n"
+                f"\nTechnical error ({error_type}): {e}"
+            )
+            raise RuntimeError(msg) from e
+        except Exception as e:
+            error_type = type(e).__name__
+            msg = (
+                f"Could not retrieve transcripts for video '{video_id}'. "
+                "Possible reasons:\n"
+                "1. This video does not have captions/transcripts enabled\n"
+                "2. The video is private, restricted, or deleted\n"
+                "3. YouTube is blocking automated requests\n"
+                f"\nTechnical error ({error_type}): {e}"
+            )
+            raise RuntimeError(msg) from e
+
+        if as_chunks:
+            # Group into chunks based on chunk_size_seconds
+            return self._chunk_transcript(transcript_data)
+        # Return as continuous text
+        return transcript_data
+
+    def _chunk_transcript(self, transcript_data):
+        """Group transcript segments into time-based chunks."""
+        chunks = []
+        current_chunk = []
+        chunk_start = 0
+
+        for segment in transcript_data:
+            # Handle both dict (old API) and object (new API) formats
+            segment_start = segment.start if hasattr(segment, "start") else segment["start"]
+
+            # If this segment starts beyond the current chunk window, start a new chunk
+            if segment_start - chunk_start >= self.chunk_size_seconds and current_chunk:
+                chunk_text = " ".join(s.text if hasattr(s, "text") else s["text"] for s in current_chunk)
+                chunks.append({"start": chunk_start, "text": chunk_text})
+                current_chunk = []
+                chunk_start = segment_start
+
+            current_chunk.append(segment)
+
+        # Add the last chunk
+        if current_chunk:
+            chunk_text = " ".join(s.text if hasattr(s, "text") else s["text"] for s in current_chunk)
+            chunks.append({"start": chunk_start, "text": chunk_text})
+
+        return chunks
 
     def get_dataframe_output(self) -> DataFrame:
         """Provides transcript output as a DataFrame with timestamp and text columns."""
         try:
-            transcripts = self._load_transcripts(as_chunks=True)
+            chunks = self._load_transcripts(as_chunks=True)
 
             # Create DataFrame with timestamp and text columns
             data = []
-            for doc in transcripts:
-                start_seconds = int(doc.metadata["start_seconds"])
+            for chunk in chunks:
+                start_seconds = int(chunk["start"])
                 start_minutes = start_seconds // 60
-                start_seconds %= 60
-                timestamp = f"{start_minutes:02d}:{start_seconds:02d}"
-                data.append({"timestamp": timestamp, "text": doc.page_content})
+                start_seconds_remainder = start_seconds % 60
+                timestamp = f"{start_minutes:02d}:{start_seconds_remainder:02d}"
+                data.append({"timestamp": timestamp, "text": chunk["text"]})
 
             return DataFrame(pd.DataFrame(data))
 
-        except (youtube_transcript_api.TranscriptsDisabled, youtube_transcript_api.NoTranscriptFound) as exc:
-            return DataFrame(pd.DataFrame({"error": [f"Failed to get YouTube transcripts: {exc!s}"]}))
+        except (TranscriptsDisabled, NoTranscriptFound, RuntimeError, ValueError) as exc:
+            error_msg = f"Failed to get YouTube transcripts: {exc!s}"
+            return DataFrame(pd.DataFrame({"error": [error_msg]}))
 
     def get_message_output(self) -> Message:
         """Provides transcript output as continuous text."""
         try:
-            transcripts = self._load_transcripts(as_chunks=False)
-            result = transcripts[0].page_content
+            transcript_data = self._load_transcripts(as_chunks=False)
+            # Handle both dict (old API) and object (new API) formats
+            result = " ".join(
+                segment.text if hasattr(segment, "text") else segment["text"] for segment in transcript_data
+            )
             return Message(text=result)
 
-        except (youtube_transcript_api.TranscriptsDisabled, youtube_transcript_api.NoTranscriptFound) as exc:
+        except (TranscriptsDisabled, NoTranscriptFound, RuntimeError, ValueError) as exc:
             error_msg = f"Failed to get YouTube transcripts: {exc!s}"
             return Message(text=error_msg)
 
@@ -100,19 +190,17 @@ class YouTubeTranscriptsComponent(Component):
         default_data = {"transcript": "", "video_url": self.url, "error": None}
 
         try:
-            transcripts = self._load_transcripts(as_chunks=False)
-            if not transcripts:
+            transcript_data = self._load_transcripts(as_chunks=False)
+            if not transcript_data:
                 default_data["error"] = "No transcripts found."
                 return Data(data=default_data)
 
-            # Combine all transcript parts
-            full_transcript = " ".join(doc.page_content for doc in transcripts)
+            # Combine all transcript segments - handle both dict and object formats
+            full_transcript = " ".join(
+                segment.text if hasattr(segment, "text") else segment["text"] for segment in transcript_data
+            )
             return Data(data={"transcript": full_transcript, "video_url": self.url})
 
-        except (
-            youtube_transcript_api.TranscriptsDisabled,
-            youtube_transcript_api.NoTranscriptFound,
-            youtube_transcript_api.CouldNotRetrieveTranscript,
-        ) as exc:
+        except (TranscriptsDisabled, NoTranscriptFound, RuntimeError, ValueError) as exc:
             default_data["error"] = str(exc)
             return Data(data=default_data)