lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev41__py3-none-any.whl

lfx/components/docling/docling_remote_vlm.py

@@ -1,284 +0,0 @@
-from typing import Any
-
-import requests
-from docling.datamodel.base_models import ConversionStatus, InputFormat
-from docling.datamodel.pipeline_options import (
-    ApiVlmOptions,
-    ResponseFormat,
-    VlmPipelineOptions,
-)
-from docling.document_converter import DocumentConverter, PdfFormatOption
-from docling.pipeline.vlm_pipeline import VlmPipeline
-from langflow.base.data import BaseFileComponent
-from langflow.inputs import DropdownInput, SecretStrInput, StrInput
-from langflow.schema import Data
-from langflow.schema.dotdict import dotdict
-
-from lfx.components.ibm.watsonx import WatsonxAIComponent
-from lfx.log.logger import logger
-
-
-class DoclingRemoteVLMComponent(BaseFileComponent):
-    display_name = "Docling Remote VLM"
-    description = (
-        "Uses Docling to process input documents running a VLM pipeline with a remote model"
-        "(OpenAI-compatible API or IBM Cloud)."
-    )
-    documentation = "https://docling-project.github.io/docling/examples/vlm_pipeline_api_model/"
-    trace_type = "tool"
-    icon = "Docling"
-    name = "DoclingRemoteVLM"
-
-    # https://docling-project.github.io/docling/usage/supported_formats/
-    VALID_EXTENSIONS = [
-        "adoc",
-        "asciidoc",
-        "asc",
-        "bmp",
-        "csv",
-        "dotx",
-        "dotm",
-        "docm",
-        "docx",
-        "htm",
-        "html",
-        "jpeg",
-        "json",
-        "md",
-        "pdf",
-        "png",
-        "potx",
-        "ppsx",
-        "pptm",
-        "potm",
-        "ppsm",
-        "pptx",
-        "tiff",
-        "txt",
-        "xls",
-        "xlsx",
-        "xhtml",
-        "xml",
-        "webp",
-    ]
-
-    inputs = [
-        *BaseFileComponent.get_base_inputs(),
-        DropdownInput(
-            name="provider",
-            display_name="Provider",
-            info="Select which remote VLM provider to use.",
-            options=["IBM Cloud", "OpenAI-Compatible"],
-            value="IBM Cloud",
-            real_time_refresh=True,
-        ),
-        # IBM Cloud inputs
-        SecretStrInput(
-            name="watsonx_api_key",
-            display_name="Watsonx API Key",
-            info="IBM Cloud API key used for authentication (leave blank to load from .env).",
-            required=False,
-        ),
-        StrInput(
-            name="watsonx_project_id",
-            display_name="Watsonx Project ID",
-            required=False,
-            info="The Watsonx project ID or deployment space ID associated with the model.",
-            value="",
-        ),
-        DropdownInput(
-            name="url",
-            display_name="Watsonx API Endpoint",
-            info="The base URL of the Watsonx API.",
-            options=[
-                "https://us-south.ml.cloud.ibm.com",
-                "https://eu-de.ml.cloud.ibm.com",
-                "https://eu-gb.ml.cloud.ibm.com",
-                "https://au-syd.ml.cloud.ibm.com",
-                "https://jp-tok.ml.cloud.ibm.com",
-                "https://ca-tor.ml.cloud.ibm.com",
-            ],
-            real_time_refresh=True,
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            options=[],
-            value=None,
-            dynamic=True,
-            required=False,
-        ),
-        # OpenAI inputs
-        StrInput(
-            name="openai_base_url",
-            display_name="OpenAI-Compatible API Base URL",
-            info="Example: https://openrouter.ai/api/",
-            required=False,
-            show=False,
-        ),
-        SecretStrInput(
-            name="openai_api_key",
-            display_name="API Key",
-            info="API key for OpenAI-compatible endpoints (leave blank if not required).",
-            required=False,
-            show=False,
-        ),
-        StrInput(
-            name="openai_model",
-            display_name="OpenAI Model Name",
-            info="Model ID for OpenAI-compatible provider (e.g. gpt-4o-mini).",
-            required=False,
-            show=False,
-        ),
-        StrInput(name="vlm_prompt", display_name="Prompt", info="Prompt for VLM.", required=False),
-    ]
-
-    outputs = [*BaseFileComponent.get_base_outputs()]
-
-    @staticmethod
-    def fetch_models(base_url: str) -> list[str]:
-        """Fetch available models from the Watsonx.ai API."""
-        try:
-            endpoint = f"{base_url}/ml/v1/foundation_model_specs"
-            params = {"version": "2024-09-16", "filters": "function_text_chat,!lifecycle_withdrawn"}
-            response = requests.get(endpoint, params=params, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            models = [model["model_id"] for model in data.get("resources", [])]
-            return sorted(models)
-        except (requests.RequestException, requests.HTTPError, requests.Timeout, ConnectionError, ValueError):
-            logger.exception("Error fetching models. Using default models.")
-            return WatsonxAIComponent._default_models  # noqa: SLF001
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        """Update shown fields based on chosen provider."""
-        logger.info(f"update_build_config called: field_name={field_name}, field_value={field_value}")
-
-        if field_name == "provider":
-            provider_choice = field_value
-
-            if provider_choice == "IBM Cloud":
-                build_config.model_name.show = True
-                build_config.watsonx_api_key.show = True
-                build_config.watsonx_project_id.show = True
-                build_config.url.show = True
-
-                build_config.openai_base_url.show = False
-                build_config.openai_api_key.show = False
-                build_config.openai_model.show = False
-
-            elif provider_choice == "OpenAI-Compatible":
-                build_config.model_name.show = False
-                build_config.watsonx_api_key.show = False
-                build_config.watsonx_project_id.show = False
-                build_config.url.show = False
-
-                build_config.openai_base_url.show = True
-                build_config.openai_api_key.show = True
-                build_config.openai_model.show = True
-
-        if field_name == "url":
-            provider_value = build_config.provider.value if hasattr(build_config, "provider") else None
-            if provider_value == "IBM Cloud" and field_value:
-                models = self.fetch_models(base_url=field_value)
-                build_config.model_name.options = models
-                if models:
-                    build_config.model_name.value = models[0]
-                logger.info(f"Updated Watsonx model list: {len(models)} models found.")
-
-    def watsonx_vlm_options(self, model: str, prompt: str):
-        """Creates Docling ApiVlmOptions for a watsonx VLM."""
-        api_key = getattr(self, "watsonx_api_key", "")
-        project_id = getattr(self, "watsonx_project_id", "")
-        base_url = getattr(self, "url", "https://us-south.ml.cloud.ibm.com")
-
-        def _get_iam_access_token(api_key: str) -> str:
-            res = requests.post(
-                url="https://iam.cloud.ibm.com/identity/token",
-                headers={"Content-Type": "application/x-www-form-urlencoded"},
-                data=f"grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey={api_key}",
-                timeout=90,
-            )
-            res.raise_for_status()
-            return res.json()["access_token"]
-
-        access_token = _get_iam_access_token(api_key)
-        return ApiVlmOptions(
-            url=f"{base_url}/ml/v1/text/chat?version=2023-05-29",
-            params={"model_id": model, "project_id": project_id, "parameters": {"max_new_tokens": 400}},
-            headers={"Authorization": f"Bearer {access_token}"},
-            prompt=prompt,
-            timeout=60,
-            response_format=ResponseFormat.MARKDOWN,
-        )
-
-    def openai_compatible_vlm_options(
-        self,
-        model: str,
-        prompt: str,
-        response_format: ResponseFormat,
-        url: str,
-        temperature: float = 0.7,
-        max_tokens: int = 4096,
-        api_key: str = "",
-        *,
-        skip_special_tokens: bool = False,
-    ):
-        """Create OpenAI-compatible Docling ApiVlmOptions options (e.g., LM Studio, vLLM, Ollama)."""
-        api_key = getattr(self, "openai_api_key", api_key)
-        model_override = getattr(self, "openai_model", model)
-
-        headers = {}
-        if api_key:
-            headers["Authorization"] = f"Bearer {api_key}"
-
-        return ApiVlmOptions(
-            url=f"{url}/v1/chat/completions",
-            params={"model": model_override, "max_tokens": max_tokens, "skip_special_tokens": skip_special_tokens},
-            headers=headers,
-            prompt=prompt,
-            timeout=90,
-            scale=2.0,
-            temperature=temperature,
-            response_format=response_format,
-        )
-
-    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
-        file_paths = [file.path for file in file_list if file.path]
-        if not file_paths:
-            logger.warning("No files to process.")
-            return file_list
-
-        provider = getattr(self, "provider", "IBM Cloud")
-        prompt = getattr(self, "vlm_prompt", "")
-
-        if provider == "IBM Cloud":
-            model = getattr(self, "model_name", "")
-            vlm_opts = self.watsonx_vlm_options(model=model, prompt=prompt)
-        else:
-            model = getattr(self, "openai_model", "") or getattr(self, "model_name", "")
-            base_url = getattr(self, "openai_base_url", "")
-            vlm_opts = self.openai_compatible_vlm_options(
-                model=model,
-                prompt=prompt,
-                response_format=ResponseFormat.MARKDOWN,
-                url=base_url,
-            )
-
-        pipeline_options = VlmPipelineOptions(enable_remote_services=True)
-        pipeline_options.vlm_options = vlm_opts
-
-        converter = DocumentConverter(
-            format_options={
-                InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options, pipeline_cls=VlmPipeline)
-            }
-        )
-
-        results = converter.convert_all(file_paths)
-        processed_data = [
-            Data(data={"doc": res.document, "file_path": str(res.input.file)})
-            if res.status == ConversionStatus.SUCCESS
-            else None
-            for res in results
-        ]
-        return self.rollup_data(file_list, processed_data)

lfx/components/logic/run_flow.py

@@ -1,71 +0,0 @@
-from typing import Any
-
-from lfx.base.tools.run_flow import RunFlowBaseComponent
-from lfx.helpers import run_flow
-from lfx.log.logger import logger
-from lfx.schema.dotdict import dotdict
-
-
-class RunFlowComponent(RunFlowBaseComponent):
-    display_name = "Run Flow"
-    description = (
-        "Creates a tool component from a Flow that takes all its inputs and runs it. "
-        " \n **Select a Flow to use the tool mode**"
-    )
-    documentation: str = "https://docs.langflow.org/components-logic#run-flow"
-    beta = True
-    name = "RunFlow"
-    icon = "Workflow"
-
-    inputs = RunFlowBaseComponent.get_base_inputs()
-    outputs = RunFlowBaseComponent.get_base_outputs()
-
-    async def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name == "flow_name_selected":
-            build_config["flow_name_selected"]["options"] = await self.get_flow_names()
-            missing_keys = [key for key in self.default_keys if key not in build_config]
-            if missing_keys:
-                msg = f"Missing required keys in build_config: {missing_keys}"
-                raise ValueError(msg)
-            if field_value is not None:
-                try:
-                    graph = await self.get_graph(field_value)
-                    build_config = self.update_build_config_from_graph(build_config, graph)
-                except Exception as e:
-                    msg = f"Error building graph for flow {field_value}"
-                    await logger.aexception(msg)
-                    raise RuntimeError(msg) from e
-        return build_config
-
-    async def run_flow_with_tweaks(self):
-        tweaks: dict = {}
-
-        flow_name_selected = self._attributes.get("flow_name_selected")
-        parsed_flow_tweak_data = self._attributes.get("flow_tweak_data", {})
-        if not isinstance(parsed_flow_tweak_data, dict):
-            parsed_flow_tweak_data = parsed_flow_tweak_data.dict()
-
-        if parsed_flow_tweak_data != {}:
-            for field in parsed_flow_tweak_data:
-                if "~" in field:
-                    [node, name] = field.split("~")
-                    if node not in tweaks:
-                        tweaks[node] = {}
-                    tweaks[node][name] = parsed_flow_tweak_data[field]
-        else:
-            for field in self._attributes:
-                if field not in self.default_keys and "~" in field:
-                    [node, name] = field.split("~")
-                    if node not in tweaks:
-                        tweaks[node] = {}
-                    tweaks[node][name] = self._attributes[field]
-
-        return await run_flow(
-            inputs=None,
-            output_type="all",
-            flow_id=None,
-            flow_name=flow_name_selected,
-            tweaks=tweaks,
-            user_id=str(self.user_id),
-            session_id=self.graph.session_id or self.session_id,
-        )

lfx/components/models/embedding_model.py

@@ -1,195 +0,0 @@
-from typing import Any
-
-from langchain_openai import OpenAIEmbeddings
-
-from lfx.base.embeddings.model import LCEmbeddingsModel
-from lfx.base.models.ollama_constants import OLLAMA_EMBEDDING_MODELS
-from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
-from lfx.base.models.watsonx_constants import WATSONX_EMBEDDING_MODEL_NAMES
-from lfx.field_typing import Embeddings
-from lfx.io import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    FloatInput,
-    IntInput,
-    MessageTextInput,
-    SecretStrInput,
-)
-from lfx.schema.dotdict import dotdict
-
-
-class EmbeddingModelComponent(LCEmbeddingsModel):
-    display_name = "Embedding Model"
-    description = "Generate embeddings using a specified provider."
-    documentation: str = "https://docs.langflow.org/components-embedding-models"
-    icon = "binary"
-    name = "EmbeddingModel"
-    category = "models"
-
-    inputs = [
-        DropdownInput(
-            name="provider",
-            display_name="Model Provider",
-            options=["OpenAI", "Ollama", "IBM watsonx.ai"],
-            value="OpenAI",
-            info="Select the embedding model provider",
-            real_time_refresh=True,
-            options_metadata=[{"icon": "OpenAI"}, {"icon": "Ollama"}, {"icon": "WatsonxAI"}],
-        ),
-        DropdownInput(
-            name="model",
-            display_name="Model Name",
-            options=OPENAI_EMBEDDING_MODEL_NAMES,
-            value=OPENAI_EMBEDDING_MODEL_NAMES[0],
-            info="Select the embedding model to use",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="OpenAI API Key",
-            info="Model Provider API key",
-            required=True,
-            show=True,
-            real_time_refresh=True,
-        ),
-        MessageTextInput(
-            name="api_base",
-            display_name="API Base URL",
-            info="Base URL for the API. Leave empty for default.",
-            advanced=True,
-        ),
-        # Watson-specific inputs
-        MessageTextInput(
-            name="project_id",
-            display_name="Project ID",
-            info="IBM watsonx.ai Project ID (required for IBM watsonx.ai)",
-            show=False,
-        ),
-        IntInput(
-            name="dimensions",
-            display_name="Dimensions",
-            info="The number of dimensions the resulting output embeddings should have. "
-            "Only supported by certain models.",
-            advanced=True,
-        ),
-        IntInput(name="chunk_size", display_name="Chunk Size", advanced=True, value=1000),
-        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
-        IntInput(name="max_retries", display_name="Max Retries", advanced=True, value=3),
-        BoolInput(name="show_progress_bar", display_name="Show Progress Bar", advanced=True),
-        DictInput(
-            name="model_kwargs",
-            display_name="Model Kwargs",
-            advanced=True,
-            info="Additional keyword arguments to pass to the model.",
-        ),
-    ]
-
-    def build_embeddings(self) -> Embeddings:
-        provider = self.provider
-        model = self.model
-        api_key = self.api_key
-        api_base = self.api_base
-        dimensions = self.dimensions
-        chunk_size = self.chunk_size
-        request_timeout = self.request_timeout
-        max_retries = self.max_retries
-        show_progress_bar = self.show_progress_bar
-        model_kwargs = self.model_kwargs or {}
-
-        if provider == "OpenAI":
-            if not api_key:
-                msg = "OpenAI API key is required when using OpenAI provider"
-                raise ValueError(msg)
-            return OpenAIEmbeddings(
-                model=model,
-                dimensions=dimensions or None,
-                base_url=api_base or None,
-                api_key=api_key,
-                chunk_size=chunk_size,
-                max_retries=max_retries,
-                timeout=request_timeout or None,
-                show_progress_bar=show_progress_bar,
-                model_kwargs=model_kwargs,
-            )
-
-        if provider == "Ollama":
-            try:
-                from langchain_ollama import OllamaEmbeddings
-            except ImportError:
-                try:
-                    from langchain_community.embeddings import OllamaEmbeddings
-                except ImportError:
-                    msg = "Please install langchain-ollama: pip install langchain-ollama"
-                    raise ImportError(msg) from None
-
-            return OllamaEmbeddings(
-                model=model,
-                base_url=api_base or "http://localhost:11434",
-                **model_kwargs,
-            )
-
-        if provider == "IBM watsonx.ai":
-            try:
-                from langchain_ibm import WatsonxEmbeddings
-            except ImportError:
-                msg = "Please install langchain-ibm: pip install langchain-ibm"
-                raise ImportError(msg) from None
-
-            if not api_key:
-                msg = "IBM watsonx.ai API key is required when using IBM watsonx.ai provider"
-                raise ValueError(msg)
-
-            project_id = self.project_id
-
-            if not project_id:
-                msg = "Project ID is required for IBM watsonx.ai provider"
-                raise ValueError(msg)
-
-            params = {
-                "model_id": model,
-                "url": api_base or "https://us-south.ml.cloud.ibm.com",
-                "apikey": api_key,
-            }
-
-            params["project_id"] = project_id
-
-            return WatsonxEmbeddings(**params)
-
-        msg = f"Unknown provider: {provider}"
-        raise ValueError(msg)
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
-        if field_name == "provider":
-            if field_value == "OpenAI":
-                build_config["model"]["options"] = OPENAI_EMBEDDING_MODEL_NAMES
-                build_config["model"]["value"] = OPENAI_EMBEDDING_MODEL_NAMES[0]
-                build_config["api_key"]["display_name"] = "OpenAI API Key"
-                build_config["api_key"]["required"] = True
-                build_config["api_key"]["show"] = True
-                build_config["api_base"]["display_name"] = "OpenAI API Base URL"
-                build_config["api_base"]["advanced"] = True
-                build_config["project_id"]["show"] = False
-
-            elif field_value == "Ollama":
-                build_config["model"]["options"] = OLLAMA_EMBEDDING_MODELS
-                build_config["model"]["value"] = OLLAMA_EMBEDDING_MODELS[0]
-                build_config["api_key"]["display_name"] = "API Key (Optional)"
-                build_config["api_key"]["required"] = False
-                build_config["api_key"]["show"] = False
-                build_config["api_base"]["display_name"] = "Ollama Base URL"
-                build_config["api_base"]["value"] = "http://localhost:11434"
-                build_config["api_base"]["advanced"] = True
-                build_config["project_id"]["show"] = False
-
-            elif field_value == "IBM watsonx.ai":
-                build_config["model"]["options"] = WATSONX_EMBEDDING_MODEL_NAMES
-                build_config["model"]["value"] = WATSONX_EMBEDDING_MODEL_NAMES[0]
-                build_config["api_key"]["display_name"] = "IBM watsonx.ai API Key"
-                build_config["api_key"]["required"] = True
-                build_config["api_key"]["show"] = True
-                build_config["api_base"]["display_name"] = "IBM watsonx.ai URL"
-                build_config["api_base"]["value"] = "https://us-south.ml.cloud.ibm.com"
-                build_config["api_base"]["advanced"] = False
-                build_config["project_id"]["show"] = True
-
-        return build_config