langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev5__py3-none-any.whl

langflow/components/nvidia/nvidia_ingest.py

@@ -1,317 +0,0 @@
-from urllib.parse import urlparse
-
-from pypdf import PdfReader
-
-from langflow.base.data.base_file import BaseFileComponent
-from langflow.inputs.inputs import BoolInput, DropdownInput, FloatInput, IntInput, MessageTextInput, SecretStrInput
-from langflow.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._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._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)

langflow/components/nvidia/nvidia_rerank.py

@@ -1,63 +0,0 @@
-from typing import Any
-
-from langflow.base.compressors.model import LCCompressorComponent
-from langflow.field_typing import BaseDocumentCompressor
-from langflow.inputs.inputs import SecretStrInput
-from langflow.io import DropdownInput, StrInput
-from langflow.schema.dotdict import dotdict
-from langflow.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)

langflow/components/nvidia/system_assist.py

@@ -1,65 +0,0 @@
-import asyncio
-
-from langflow.custom.custom_component.component_with_cache import ComponentWithCache
-from langflow.io import MessageTextInput, Output
-from langflow.schema import Message
-from langflow.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)

langflow/components/olivya/__init__.py

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

langflow/components/olivya/olivya.py

@@ -1,116 +0,0 @@
-import json
-
-import httpx
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output
-from langflow.logging.logger import logger
-from langflow.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)

langflow/components/ollama/__init__.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.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__)