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

lfx/components/nvidia/nvidia_ingest.py

@@ -0,0 +1,317 @@
+from urllib.parse import urlparse
+
+from pypdf import PdfReader
+
+from lfx.base.data.base_file import BaseFileComponent
+from lfx.inputs.inputs import BoolInput, DropdownInput, FloatInput, IntInput, MessageTextInput, SecretStrInput
+from lfx.schema.data import Data
+
+
+class NvidiaIngestComponent(BaseFileComponent):
+    display_name = "NVIDIA Retriever Extraction"
+    description = "Multi-modal data extraction from documents using NVIDIA's NeMo API."
+    documentation: str = "https://docs.nvidia.com/nemo/retriever/extraction/overview/"
+    icon = "NVIDIA"
+    beta = True
+
+    try:
+        from nv_ingest_client.util.file_processing.extract import EXTENSION_TO_DOCUMENT_TYPE
+
+        # Supported file extensions from https://github.com/NVIDIA/nv-ingest/blob/main/README.md
+        VALID_EXTENSIONS = ["pdf", "docx", "pptx", "jpeg", "png", "svg", "tiff", "txt"]
+    except ImportError:
+        msg = (
+            "NVIDIA Retriever Extraction (nv-ingest) is an optional dependency. "
+            "Install with `uv pip install 'langflow[nv-ingest]'` "
+            "(requires Python 3.12>=)"
+        )
+        VALID_EXTENSIONS = [msg]
+
+    inputs = [
+        *BaseFileComponent.get_base_inputs(),
+        MessageTextInput(
+            name="base_url",
+            display_name="Base URL",
+            info="The URL of the NVIDIA NeMo Retriever Extraction API.",
+            required=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="NVIDIA API Key",
+        ),
+        BoolInput(
+            name="extract_text",
+            display_name="Extract Text",
+            info="Extract text from documents",
+            value=True,
+        ),
+        BoolInput(
+            name="extract_charts",
+            display_name="Extract Charts",
+            info="Extract text from charts",
+            value=False,
+        ),
+        BoolInput(
+            name="extract_tables",
+            display_name="Extract Tables",
+            info="Extract text from tables",
+            value=False,
+        ),
+        BoolInput(
+            name="extract_images",
+            display_name="Extract Images",
+            info="Extract images from document",
+            value=True,
+        ),
+        BoolInput(
+            name="extract_infographics",
+            display_name="Extract Infographics",
+            info="Extract infographics from document",
+            value=False,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="text_depth",
+            display_name="Text Depth",
+            info=(
+                "Level at which text is extracted (applies before splitting). "
+                "Support for 'block', 'line', 'span' varies by document type."
+            ),
+            options=["document", "page", "block", "line", "span"],
+            value="page",  # Default value
+            advanced=True,
+        ),
+        BoolInput(
+            name="split_text",
+            display_name="Split Text",
+            info="Split text into smaller chunks",
+            value=True,
+            advanced=True,
+        ),
+        IntInput(
+            name="chunk_size",
+            display_name="Chunk size",
+            info="The number of tokens per chunk",
+            value=500,
+            advanced=True,
+        ),
+        IntInput(
+            name="chunk_overlap",
+            display_name="Chunk Overlap",
+            info="Number of tokens to overlap from previous chunk",
+            value=150,
+            advanced=True,
+        ),
+        BoolInput(
+            name="filter_images",
+            display_name="Filter Images",
+            info="Filter images (see advanced options for filtering criteria).",
+            advanced=True,
+            value=False,
+        ),
+        IntInput(
+            name="min_image_size",
+            display_name="Minimum Image Size Filter",
+            info="Minimum image width/length in pixels",
+            value=128,
+            advanced=True,
+        ),
+        FloatInput(
+            name="min_aspect_ratio",
+            display_name="Minimum Aspect Ratio Filter",
+            info="Minimum allowed aspect ratio (width / height). Images narrower than this will be filtered out.",
+            value=0.2,
+            advanced=True,
+        ),
+        FloatInput(
+            name="max_aspect_ratio",
+            display_name="Maximum Aspect Ratio Filter",
+            info="Maximum allowed aspect ratio (width / height). Images taller than this will be filtered out.",
+            value=5.0,
+            advanced=True,
+        ),
+        BoolInput(
+            name="dedup_images",
+            display_name="Deduplicate Images",
+            info="Filter duplicated images.",
+            advanced=True,
+            value=True,
+        ),
+        BoolInput(
+            name="caption_images",
+            display_name="Caption Images",
+            info="Generate captions for images using the NVIDIA captioning model.",
+            advanced=True,
+            value=True,
+        ),
+        BoolInput(
+            name="high_resolution",
+            display_name="High Resolution (PDF only)",
+            info=("Process pdf in high-resolution mode for better quality extraction from scanned pdf."),
+            advanced=True,
+            value=False,
+        ),
+    ]
+
+    outputs = [
+        *BaseFileComponent.get_base_outputs(),
+    ]
+
+    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        try:
+            from nv_ingest_client.client import Ingestor
+        except ImportError as e:
+            msg = (
+                "NVIDIA Retriever Extraction (nv-ingest) dependencies missing. "
+                "Please install them using your package manager. (e.g. uv pip install langflow[nv-ingest])"
+            )
+            raise ImportError(msg) from e
+
+        if not file_list:
+            err_msg = "No files to process."
+            self.log(err_msg)
+            raise ValueError(err_msg)
+
+        # Check if all files are PDFs when high resolution mode is enabled
+        if self.high_resolution:
+            for file in file_list:
+                try:
+                    with file.path.open("rb") as f:
+                        PdfReader(f)
+                except Exception as exc:
+                    error_msg = "High-resolution mode only supports valid PDF files."
+                    self.log(error_msg)
+                    raise ValueError(error_msg) from exc
+
+        file_paths = [str(file.path) for file in file_list]
+
+        self.base_url: str | None = self.base_url.strip() if self.base_url else None
+        if self.base_url:
+            try:
+                urlparse(self.base_url)
+            except Exception as e:
+                error_msg = f"Invalid Base URL format: {e}"
+                self.log(error_msg)
+                raise ValueError(error_msg) from e
+        else:
+            base_url_error = "Base URL is required"
+            raise ValueError(base_url_error)
+
+        self.log(
+            f"Creating Ingestor for Base URL: {self.base_url!r}",
+        )
+
+        try:
+            ingestor = (
+                Ingestor(
+                    message_client_kwargs={
+                        "base_url": self.base_url,
+                        "headers": {"Authorization": f"Bearer {self.api_key}"},
+                        "max_retries": 3,
+                        "timeout": 60,
+                    }
+                )
+                .files(file_paths)
+                .extract(
+                    extract_text=self.extract_text,
+                    extract_tables=self.extract_tables,
+                    extract_charts=self.extract_charts,
+                    extract_images=self.extract_images,
+                    extract_infographics=self.extract_infographics,
+                    text_depth=self.text_depth,
+                    **({"extract_method": "nemoretriever_parse"} if self.high_resolution else {}),
+                )
+            )
+
+            if self.extract_images:
+                if self.dedup_images:
+                    ingestor = ingestor.dedup(content_type="image", filter=True)
+
+                if self.filter_images:
+                    ingestor = ingestor.filter(
+                        content_type="image",
+                        min_size=self.min_image_size,
+                        min_aspect_ratio=self.min_aspect_ratio,
+                        max_aspect_ratio=self.max_aspect_ratio,
+                        filter=True,
+                    )
+
+                if self.caption_images:
+                    ingestor = ingestor.caption()
+
+            if self.extract_text and self.split_text:
+                ingestor = ingestor.split(
+                    tokenizer="intfloat/e5-large-unsupervised",
+                    chunk_size=self.chunk_size,
+                    chunk_overlap=self.chunk_overlap,
+                    params={"split_source_types": ["PDF"]},
+                )
+
+            result = ingestor.ingest()
+        except Exception as e:
+            ingest_error = f"Error during ingestion: {e}"
+            self.log(ingest_error)
+            raise
+
+        self.log(f"Results: {result}")
+
+        data: list[Data | None] = []
+        document_type_text = "text"
+        document_type_structured = "structured"
+
+        # Result is a list of segments as determined by the text_depth option (if "document" then only one segment)
+        # each segment is a list of elements (text, structured, image)
+        for segment in result:
+            if segment:
+                for element in segment:
+                    document_type = element.get("document_type")
+                    metadata = element.get("metadata", {})
+                    source_metadata = metadata.get("source_metadata", {})
+
+                    if document_type == document_type_text:
+                        data.append(
+                            Data(
+                                text=metadata.get("content", ""),
+                                file_path=source_metadata.get("source_name", ""),
+                                document_type=document_type,
+                                metadata=metadata,
+                            )
+                        )
+                    # Both charts and tables are returned as "structured" document type,
+                    # with extracted text in "table_content"
+                    elif document_type == document_type_structured:
+                        table_metadata = metadata.get("table_metadata", {})
+
+                        # reformat chart/table images as binary data
+                        if "content" in metadata:
+                            metadata["content"] = {"$binary": metadata["content"]}
+
+                        data.append(
+                            Data(
+                                text=table_metadata.get("table_content", ""),
+                                file_path=source_metadata.get("source_name", ""),
+                                document_type=document_type,
+                                metadata=metadata,
+                            )
+                        )
+                    elif document_type == "image":
+                        image_metadata = metadata.get("image_metadata", {})
+
+                        # reformat images as binary data
+                        if "content" in metadata:
+                            metadata["content"] = {"$binary": metadata["content"]}
+
+                        data.append(
+                            Data(
+                                text=image_metadata.get("caption", "No caption available"),
+                                file_path=source_metadata.get("source_name", ""),
+                                document_type=document_type,
+                                metadata=metadata,
+                            )
+                        )
+                    else:
+                        self.log(f"Unsupported document type {document_type}")
+        self.status = data or "No data"
+
+        # merge processed data with BaseFile objects
+        return self.rollup_data(file_list, data)

lfx/components/nvidia/nvidia_rerank.py

@@ -0,0 +1,63 @@
+from typing import Any
+
+from lfx.base.compressors.model import LCCompressorComponent
+from lfx.field_typing import BaseDocumentCompressor
+from lfx.inputs.inputs import SecretStrInput
+from lfx.io import DropdownInput, StrInput
+from lfx.schema.dotdict import dotdict
+from lfx.template.field.base import Output
+
+
+class NvidiaRerankComponent(LCCompressorComponent):
+    display_name = "NVIDIA Rerank"
+    description = "Rerank documents using the NVIDIA API."
+    icon = "NVIDIA"
+
+    inputs = [
+        *LCCompressorComponent.inputs,
+        SecretStrInput(
+            name="api_key",
+            display_name="NVIDIA API Key",
+        ),
+        StrInput(
+            name="base_url",
+            display_name="Base URL",
+            value="https://integrate.api.nvidia.com/v1",
+            refresh_button=True,
+            info="The base URL of the NVIDIA API. Defaults to https://integrate.api.nvidia.com/v1.",
+        ),
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            options=["nv-rerank-qa-mistral-4b:1"],
+            value="nv-rerank-qa-mistral-4b:1",
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Reranked Documents",
+            name="reranked_documents",
+            method="compress_documents",
+        ),
+    ]
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        if field_name == "base_url" and field_value:
+            try:
+                build_model = self.build_compressor()
+                ids = [model.id for model in build_model.available_models]
+                build_config["model"]["options"] = ids
+                build_config["model"]["value"] = ids[0]
+            except Exception as e:
+                msg = f"Error getting model names: {e}"
+                raise ValueError(msg) from e
+        return build_config
+
+    def build_compressor(self) -> BaseDocumentCompressor:
+        try:
+            from langchain_nvidia_ai_endpoints import NVIDIARerank
+        except ImportError as e:
+            msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
+            raise ImportError(msg) from e
+        return NVIDIARerank(api_key=self.api_key, model=self.model, base_url=self.base_url, top_n=self.top_n)

lfx/components/nvidia/system_assist.py

@@ -0,0 +1,65 @@
+import asyncio
+
+from lfx.custom.custom_component.component_with_cache import ComponentWithCache
+from lfx.io import MessageTextInput, Output
+from lfx.schema import Message
+from lfx.services.cache.utils import CacheMiss
+
+RISE_INITIALIZED_KEY = "rise_initialized"
+
+
+class NvidiaSystemAssistComponent(ComponentWithCache):
+    display_name = "NVIDIA System-Assist"
+    description = (
+        "(Windows only) Prompts NVIDIA System-Assist to interact with the NVIDIA GPU Driver. "
+        "The user may query GPU specifications, state, and ask the NV-API to perform "
+        "several GPU-editing acations. The prompt must be human-readable language."
+    )
+    documentation = "https://docs.langflow.org/components-custom-components"
+    icon = "NVIDIA"
+    rise_initialized = False
+
+    inputs = [
+        MessageTextInput(
+            name="prompt",
+            display_name="System-Assist Prompt",
+            info="Enter a prompt for NVIDIA System-Assist to process. Example: 'What is my GPU?'",
+            value="",
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Response", name="response", method="sys_assist_prompt"),
+    ]
+
+    def maybe_register_rise_client(self):
+        try:
+            from gassist.rise import register_rise_client
+
+            rise_initialized = self._shared_component_cache.get(RISE_INITIALIZED_KEY)
+            if not isinstance(rise_initialized, CacheMiss) and rise_initialized:
+                return
+            self.log("Initializing Rise Client")
+
+            register_rise_client()
+            self._shared_component_cache.set(key=RISE_INITIALIZED_KEY, value=True)
+        except ImportError as e:
+            msg = "NVIDIA System-Assist is Windows only and not supported on this platform"
+            raise ValueError(msg) from e
+        except Exception as e:
+            msg = f"An error occurred initializing NVIDIA System-Assist: {e}"
+            raise ValueError(msg) from e
+
+    async def sys_assist_prompt(self) -> Message:
+        try:
+            from gassist.rise import send_rise_command
+        except ImportError as e:
+            msg = "NVIDIA System-Assist is Windows only and not supported on this platform"
+            raise ValueError(msg) from e
+
+        self.maybe_register_rise_client()
+
+        response = await asyncio.to_thread(send_rise_command, self.prompt)
+
+        return Message(text=response["completed_response"]) if response is not None else Message(text=None)

lfx/components/olivya/__init__.py

@@ -0,0 +1,3 @@
+from .olivya import OlivyaComponent
+
+__all__ = ["OlivyaComponent"]

lfx/components/olivya/olivya.py

@@ -0,0 +1,116 @@
+import json
+
+import httpx
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+
+class OlivyaComponent(Component):
+    display_name = "Place Call"
+    description = "A component to create an outbound call request from Olivya's platform."
+    documentation: str = "http://docs.langflow.org/components/olivya"
+    icon = "Olivya"
+    name = "OlivyaComponent"
+
+    inputs = [
+        MessageTextInput(
+            name="api_key",
+            display_name="API Key",
+            info="Your API key for authentication",
+            value="",
+            required=True,
+        ),
+        MessageTextInput(
+            name="from_number",
+            display_name="From Number",
+            info="The Agent's phone number",
+            value="",
+            required=True,
+        ),
+        MessageTextInput(
+            name="to_number",
+            display_name="To Number",
+            info="The recipient's phone number",
+            value="",
+            required=True,
+        ),
+        MessageTextInput(
+            name="first_message",
+            display_name="First Message",
+            info="The Agent's introductory message",
+            value="",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="system_prompt",
+            display_name="System Prompt",
+            info="The system prompt to guide the interaction",
+            value="",
+            required=False,
+        ),
+        MessageTextInput(
+            name="conversation_history",
+            display_name="Conversation History",
+            info="The summary of the conversation",
+            value="",
+            required=False,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Output", name="output", method="build_output"),
+    ]
+
+    async def build_output(self) -> Data:
+        try:
+            payload = {
+                "variables": {
+                    "first_message": self.first_message.strip() if self.first_message else None,
+                    "system_prompt": self.system_prompt.strip() if self.system_prompt else None,
+                    "conversation_history": self.conversation_history.strip() if self.conversation_history else None,
+                },
+                "from_number": self.from_number.strip(),
+                "to_number": self.to_number.strip(),
+            }
+
+            headers = {
+                "Authorization": self.api_key.strip(),
+                "Content-Type": "application/json",
+            }
+
+            await logger.ainfo("Sending POST request with payload: %s", payload)
+
+            # Send the POST request with a timeout
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    "https://phone.olivya.io/create_zap_call",
+                    headers=headers,
+                    json=payload,
+                    timeout=10.0,
+                )
+                response.raise_for_status()
+
+                # Parse and return the successful response
+                response_data = response.json()
+                await logger.ainfo("Request successful: %s", response_data)
+
+        except httpx.HTTPStatusError as http_err:
+            await logger.aexception("HTTP error occurred")
+            response_data = {"error": f"HTTP error occurred: {http_err}", "response_text": response.text}
+        except httpx.RequestError as req_err:
+            await logger.aexception("Request failed")
+            response_data = {"error": f"Request failed: {req_err}"}
+        except json.JSONDecodeError as json_err:
+            await logger.aexception("Response parsing failed")
+            response_data = {"error": f"Response parsing failed: {json_err}", "raw_response": response.text}
+        except Exception as e:  # noqa: BLE001
+            await logger.aexception("An unexpected error occurred")
+            response_data = {"error": f"An unexpected error occurred: {e!s}"}
+
+        # Return the response as part of the output
+        return Data(value=response_data)

lfx/components/ollama/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .ollama import ChatOllamaComponent
+    from .ollama_embeddings import OllamaEmbeddingsComponent
+
+_dynamic_imports = {
+    "ChatOllamaComponent": "ollama",
+    "OllamaEmbeddingsComponent": "ollama_embeddings",
+}
+
+__all__ = [
+    "ChatOllamaComponent",
+    "OllamaEmbeddingsComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import ollama components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)