lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/vertexai/vertexai_embeddings.py

@@ -0,0 +1,67 @@
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.io import BoolInput, FileInput, FloatInput, IntInput, MessageTextInput, Output
+
+
+class VertexAIEmbeddingsComponent(LCModelComponent):
+    display_name = "Vertex AI Embeddings"
+    description = "Generate embeddings using Google Cloud Vertex AI models."
+    icon = "VertexAI"
+    name = "VertexAIEmbeddings"
+
+    inputs = [
+        FileInput(
+            name="credentials",
+            display_name="Credentials",
+            info="JSON credentials file. Leave empty to fallback to environment variables",
+            value="",
+            file_types=["json"],
+            required=True,
+        ),
+        MessageTextInput(name="location", display_name="Location", value="us-central1", advanced=True),
+        MessageTextInput(name="project", display_name="Project", info="The project ID.", advanced=True),
+        IntInput(name="max_output_tokens", display_name="Max Output Tokens", advanced=True),
+        IntInput(name="max_retries", display_name="Max Retries", value=1, advanced=True),
+        MessageTextInput(name="model_name", display_name="Model Name", value="textembedding-gecko", required=True),
+        IntInput(name="n", display_name="N", value=1, advanced=True),
+        IntInput(name="request_parallelism", value=5, display_name="Request Parallelism", advanced=True),
+        MessageTextInput(name="stop_sequences", display_name="Stop", advanced=True, is_list=True),
+        BoolInput(name="streaming", display_name="Streaming", value=False, advanced=True),
+        FloatInput(name="temperature", value=0.0, display_name="Temperature"),
+        IntInput(name="top_k", display_name="Top K", advanced=True),
+        FloatInput(name="top_p", display_name="Top P", value=0.95, advanced=True),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            from langchain_google_vertexai import VertexAIEmbeddings
+        except ImportError as e:
+            msg = "Please install the langchain-google-vertexai package to use the VertexAIEmbeddings component."
+            raise ImportError(msg) from e
+
+        from google.oauth2 import service_account
+
+        if self.credentials:
+            gcloud_credentials = service_account.Credentials.from_service_account_file(self.credentials)
+        else:
+            # will fallback to environment variable or inferred from gcloud CLI
+            gcloud_credentials = None
+        return VertexAIEmbeddings(
+            credentials=gcloud_credentials,
+            location=self.location,
+            max_output_tokens=self.max_output_tokens or None,
+            max_retries=self.max_retries,
+            model_name=self.model_name,
+            n=self.n,
+            project=self.project,
+            request_parallelism=self.request_parallelism,
+            stop=self.stop_sequences or None,
+            streaming=self.streaming,
+            temperature=self.temperature,
+            top_k=self.top_k or None,
+            top_p=self.top_p,
+        )

lfx/components/vlmrun/__init__.py

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

@@ -0,0 +1,224 @@
+from pathlib import Path
+from urllib.parse import urlparse
+
+from langflow.custom.custom_component.component import Component
+from langflow.io import (
+    DropdownInput,
+    FileInput,
+    IntInput,
+    MessageTextInput,
+    Output,
+    SecretStrInput,
+)
+from langflow.schema.data import Data
+from loguru import logger
+
+
+class VLMRunTranscription(Component):
+    display_name = "VLM Run Transcription"
+    description = "Extract structured data from audio and video using [VLM Run AI](https://app.vlm.run)"
+    documentation = "https://docs.vlm.run"
+    icon = "VLMRun"
+    beta = True
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="VLM Run API Key",
+            info="Get your API key from https://app.vlm.run",
+            required=True,
+        ),
+        DropdownInput(
+            name="media_type",
+            display_name="Media Type",
+            options=["audio", "video"],
+            value="audio",
+            info="Select the type of media to process",
+        ),
+        FileInput(
+            name="media_files",
+            display_name="Media Files",
+            file_types=[
+                "mp3",
+                "wav",
+                "m4a",
+                "flac",
+                "ogg",
+                "opus",
+                "webm",
+                "aac",
+                "mp4",
+                "mov",
+                "avi",
+                "mkv",
+                "flv",
+                "wmv",
+                "m4v",
+            ],
+            info="Upload one or more audio/video files",
+            required=False,
+            is_list=True,
+        ),
+        MessageTextInput(
+            name="media_url",
+            display_name="Media URL",
+            info="URL to media file (alternative to file upload)",
+            required=False,
+            advanced=True,
+        ),
+        IntInput(
+            name="timeout_seconds",
+            display_name="Timeout (seconds)",
+            value=600,
+            info="Maximum time to wait for processing completion",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="domain",
+            display_name="Processing Domain",
+            options=["transcription"],
+            value="transcription",
+            info="Select the processing domain",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Result",
+            name="result",
+            method="process_media",
+        ),
+    ]
+
+    def _check_inputs(self) -> str | None:
+        """Validate that either media files or URL is provided."""
+        if not self.media_files and not self.media_url:
+            return "Either media files or media URL must be provided"
+        return None
+
+    def _import_vlmrun(self):
+        """Import and return VLMRun client class."""
+        try:
+            from vlmrun.client import VLMRun
+        except ImportError as e:
+            error_msg = "VLM Run SDK not installed. Run: pip install 'vlmrun[all]'"
+            raise ImportError(error_msg) from e
+        else:
+            return VLMRun
+
+    def _generate_media_response(self, client, media_source):
+        """Generate response for audio or video media."""
+        domain_str = f"{self.media_type}.{self.domain}"
+
+        if self.media_type == "audio":
+            if isinstance(media_source, Path):
+                return client.audio.generate(file=media_source, domain=domain_str, batch=True)
+            return client.audio.generate(url=media_source, domain=domain_str, batch=True)
+        # video
+        if isinstance(media_source, Path):
+            return client.video.generate(file=media_source, domain=domain_str, batch=True)
+        return client.video.generate(url=media_source, domain=domain_str, batch=True)
+
+    def _wait_for_response(self, client, response):
+        """Wait for batch processing to complete if needed."""
+        if hasattr(response, "id"):
+            return client.predictions.wait(response.id, timeout=self.timeout_seconds)
+        return response
+
+    def _extract_transcription(self, segments: list) -> list[str]:
+        """Extract transcription parts from segments."""
+        transcription_parts = []
+        for segment in segments:
+            if self.media_type == "audio" and "audio" in segment:
+                transcription_parts.append(segment["audio"].get("content", ""))
+            elif self.media_type == "video" and "video" in segment:
+                transcription_parts.append(segment["video"].get("content", ""))
+                # Also include audio if available for video
+                if "audio" in segment:
+                    audio_content = segment["audio"].get("content", "")
+                    if audio_content and audio_content.strip():
+                        transcription_parts.append(f"[Audio: {audio_content}]")
+        return transcription_parts
+
+    def _create_result_dict(self, response, transcription_parts: list, source_name: str) -> dict:
+        """Create a standardized result dictionary."""
+        response_data = response.response if hasattr(response, "response") else {}
+        result = {
+            "prediction_id": response.id if hasattr(response, "id") else None,
+            "transcription": " ".join(transcription_parts),
+            "full_response": response_data,
+            "metadata": {
+                "media_type": self.media_type,
+                "duration": response_data.get("metadata", {}).get("duration", 0),
+            },
+            "usage": response.usage if hasattr(response, "usage") else None,
+            "status": response.status if hasattr(response, "status") else "completed",
+        }
+
+        # Add source-specific field
+        parsed_url = urlparse(source_name)
+        if parsed_url.scheme in ["http", "https", "s3", "gs", "ftp", "ftps"]:
+            result["source"] = source_name
+        else:
+            result["filename"] = source_name
+
+        return result
+
+    def _process_single_media(self, client, media_source, source_name: str) -> dict:
+        """Process a single media file or URL."""
+        response = self._generate_media_response(client, media_source)
+        response = self._wait_for_response(client, response)
+        response_data = response.response if hasattr(response, "response") else {}
+        segments = response_data.get("segments", [])
+        transcription_parts = self._extract_transcription(segments)
+        return self._create_result_dict(response, transcription_parts, source_name)
+
+    def process_media(self) -> Data:
+        """Process audio or video file and extract structured data."""
+        # Validate inputs
+        error_msg = self._check_inputs()
+        if error_msg:
+            self.status = error_msg
+            return Data(data={"error": error_msg})
+
+        try:
+            # Import and initialize client
+            vlmrun_class = self._import_vlmrun()
+            client = vlmrun_class(api_key=self.api_key)
+            all_results = []
+
+            # Handle multiple files
+            if self.media_files:
+                files_to_process = self.media_files if isinstance(self.media_files, list) else [self.media_files]
+                for idx, media_file in enumerate(files_to_process):
+                    self.status = f"Processing file {idx + 1} of {len(files_to_process)}..."
+                    result = self._process_single_media(client, Path(media_file), Path(media_file).name)
+                    all_results.append(result)
+
+            # Handle URL
+            elif self.media_url:
+                result = self._process_single_media(client, self.media_url, self.media_url)
+                all_results.append(result)
+
+            # Return clean, flexible output structure
+            output_data = {
+                "results": all_results,
+                "total_files": len(all_results),
+            }
+            self.status = f"Successfully processed {len(all_results)} file(s)"
+            return Data(data=output_data)
+
+        except ImportError as e:
+            self.status = str(e)
+            return Data(data={"error": str(e)})
+        except (ValueError, ConnectionError, TimeoutError) as e:
+            logger.opt(exception=True).debug("Error processing media with VLM Run")
+            error_msg = f"Processing failed: {e!s}"
+            self.status = error_msg
+            return Data(data={"error": error_msg})
+        except (AttributeError, KeyError, OSError) as e:
+            logger.opt(exception=True).debug("Unexpected error processing media with VLM Run")
+            error_msg = f"Unexpected error: {e!s}"
+            self.status = error_msg
+            return Data(data={"error": error_msg})

lfx/components/weaviate/__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 .weaviate import WeaviateVectorStoreComponent
+
+_dynamic_imports = {
+    "WeaviateVectorStoreComponent": "weaviate",
+}
+
+__all__ = [
+    "WeaviateVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Weaviate 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/weaviate/weaviate.py

@@ -0,0 +1,89 @@
+import weaviate
+from langchain_community.vectorstores import Weaviate
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import BoolInput, HandleInput, IntInput, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class WeaviateVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Weaviate"
+    description = "Weaviate Vector Store with search capabilities"
+    name = "Weaviate"
+    icon = "Weaviate"
+
+    inputs = [
+        StrInput(name="url", display_name="Weaviate URL", value="http://localhost:8080", required=True),
+        SecretStrInput(name="api_key", display_name="API Key", required=False),
+        StrInput(
+            name="index_name",
+            display_name="Index Name",
+            required=True,
+            info="Requires capitalized index name.",
+        ),
+        StrInput(name="text_key", display_name="Text Key", value="text", advanced=True),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+        BoolInput(name="search_by_text", display_name="Search By Text", advanced=True),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> Weaviate:
+        if self.api_key:
+            auth_config = weaviate.AuthApiKey(api_key=self.api_key)
+            client = weaviate.Client(url=self.url, auth_client_secret=auth_config)
+        else:
+            client = weaviate.Client(url=self.url)
+
+        if self.index_name != self.index_name.capitalize():
+            msg = f"Weaviate requires the index name to be capitalized. Use: {self.index_name.capitalize()}"
+            raise ValueError(msg)
+
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        if documents and self.embedding:
+            return Weaviate.from_documents(
+                client=client,
+                index_name=self.index_name,
+                documents=documents,
+                embedding=self.embedding,
+                by_text=self.search_by_text,
+            )
+
+        return Weaviate(
+            client=client,
+            index_name=self.index_name,
+            text_key=self.text_key,
+            embedding=self.embedding,
+            by_text=self.search_by_text,
+        )
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/wikipedia/__init__.py

@@ -0,0 +1,4 @@
+from .wikidata import WikidataComponent
+from .wikipedia import WikipediaComponent
+
+__all__ = ["WikidataComponent", "WikipediaComponent"]

lfx/components/wikipedia/wikidata.py

@@ -0,0 +1,86 @@
+import httpx
+from httpx import HTTPError
+from langchain_core.tools import ToolException
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import MultilineInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+
+class WikidataComponent(Component):
+    display_name = "Wikidata"
+    description = "Performs a search using the Wikidata API."
+    icon = "Wikipedia"
+
+    inputs = [
+        MultilineInput(
+            name="query",
+            display_name="Query",
+            info="The text query for similarity search on Wikidata.",
+            required=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def fetch_content(self) -> list[Data]:
+        try:
+            # Define request parameters for Wikidata API
+            params = {
+                "action": "wbsearchentities",
+                "format": "json",
+                "search": self.query,
+                "language": "en",
+            }
+
+            # Send request to Wikidata API
+            wikidata_api_url = "https://www.wikidata.org/w/api.php"
+            response = httpx.get(wikidata_api_url, params=params)
+            response.raise_for_status()
+            response_json = response.json()
+
+            # Extract search results
+            results = response_json.get("search", [])
+
+            if not results:
+                return [Data(data={"error": "No search results found for the given query."})]
+
+            # Transform the API response into Data objects
+            data = [
+                Data(
+                    text=f"{result['label']}: {result.get('description', '')}",
+                    data={
+                        "label": result["label"],
+                        "id": result.get("id"),
+                        "url": result.get("url"),
+                        "description": result.get("description", ""),
+                        "concepturi": result.get("concepturi"),
+                    },
+                )
+                for result in results
+            ]
+
+            self.status = data
+        except HTTPError as e:
+            error_message = f"HTTP Error in Wikidata Search API: {e!s}"
+            raise ToolException(error_message) from None
+        except KeyError as e:
+            error_message = f"Data parsing error in Wikidata API response: {e!s}"
+            raise ToolException(error_message) from None
+        except ValueError as e:
+            error_message = f"Value error in Wikidata API: {e!s}"
+            raise ToolException(error_message) from None
+        else:
+            return data
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/wikipedia/wikipedia.py

@@ -0,0 +1,53 @@
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import BoolInput, IntInput, MessageTextInput, MultilineInput
+from lfx.io import Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class WikipediaComponent(Component):
+    display_name = "Wikipedia"
+    description = "Call Wikipedia API."
+    icon = "Wikipedia"
+
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            tool_mode=True,
+        ),
+        MessageTextInput(name="lang", display_name="Language", value="en"),
+        IntInput(name="k", display_name="Number of results", value=4, required=True),
+        BoolInput(name="load_all_available_meta", display_name="Load all available meta", value=False, advanced=True),
+        IntInput(
+            name="doc_content_chars_max", display_name="Document content characters max", value=4000, advanced=True
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def _build_wrapper(self) -> WikipediaAPIWrapper:
+        return WikipediaAPIWrapper(
+            top_k_results=self.k,
+            lang=self.lang,
+            load_all_available_meta=self.load_all_available_meta,
+            doc_content_chars_max=self.doc_content_chars_max,
+        )
+
+    def fetch_content(self) -> list[Data]:
+        wrapper = self._build_wrapper()
+        docs = wrapper.load(self.input_value)
+        data = [Data.from_document(doc) for doc in docs]
+        self.status = data
+        return data
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/wolframalpha/__init__.py

@@ -0,0 +1,3 @@
+from .wolfram_alpha_api import WolframAlphaAPIComponent
+
+__all__ = ["WolframAlphaAPIComponent"]

lfx/components/wolframalpha/wolfram_alpha_api.py

@@ -0,0 +1,54 @@
+from langchain_community.utilities.wolfram_alpha import WolframAlphaAPIWrapper
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import MultilineInput, SecretStrInput
+from lfx.io import Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class WolframAlphaAPIComponent(LCToolComponent):
+    display_name = "WolframAlpha API"
+    description = """Enables queries to WolframAlpha for computational data, facts, and calculations across various \
+topics, delivering structured responses."""
+    name = "WolframAlphaAPI"
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    inputs = [
+        MultilineInput(
+            name="input_value", display_name="Input Query", info="Example query: 'What is the population of France?'"
+        ),
+        SecretStrInput(name="app_id", display_name="WolframAlpha App ID", required=True),
+    ]
+
+    icon = "WolframAlphaAPI"
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def build_tool(self) -> Tool:
+        wrapper = self._build_wrapper()
+        return Tool(name="wolfram_alpha_api", description="Answers mathematical questions.", func=wrapper.run)
+
+    def _build_wrapper(self) -> WolframAlphaAPIWrapper:
+        return WolframAlphaAPIWrapper(wolfram_alpha_appid=self.app_id)
+
+    def fetch_content(self) -> list[Data]:
+        wrapper = self._build_wrapper()
+        result_str = wrapper.run(self.input_value)
+        data = [Data(text=result_str)]
+        self.status = data
+        return data
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        """Convert the WolframAlpha results to a DataFrame.
+
+        Returns:
+            DataFrame: A DataFrame containing the query results.
+        """
+        data = self.fetch_content()
+        return DataFrame(data)