lfx-openai 0.1.0__py3-none-any.whl

lfx_openai/__init__.py

@@ -0,0 +1,15 @@
+"""lfx-openai: OpenAI bundle.
+
+Distribution unit ``lfx-openai``.  At runtime Langflow's loader
+discovers ``extension.json`` shipped alongside this ``__init__.py`` and
+registers the bundle's components under the namespaced IDs
+``ext:openai:<Class>@official``.
+"""
+
+from lfx_openai.components.openai.openai import OpenAIEmbeddingsComponent
+from lfx_openai.components.openai.openai_chat_model import OpenAIModelComponent
+
+__all__ = [
+    "OpenAIEmbeddingsComponent",
+    "OpenAIModelComponent",
+]

lfx_openai/components/openai/__init__.py

@@ -0,0 +1,45 @@
+"""Lazy component re-exports for the ``openai`` bundle.
+
+Mirrors the pre-extraction layout of ``lfx.components.openai`` so saved
+flows that referenced the module-level class
+(e.g. ``lfx.components.openai.<Class>``) keep resolving via the
+migration table after rewrite to
+``lfx_openai.components.openai.<Class>``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.utils.lazy_import import import_mod
+
+if TYPE_CHECKING:
+    from .openai import OpenAIEmbeddingsComponent
+    from .openai_chat_model import OpenAIModelComponent
+
+_dynamic_imports = {
+    "OpenAIEmbeddingsComponent": "openai",
+    "OpenAIModelComponent": "openai_chat_model",
+}
+
+__all__ = [
+    "OpenAIEmbeddingsComponent",
+    "OpenAIModelComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    if attr_name not in _dynamic_imports:
+        msg = f"module {__name__!r} has no attribute {attr_name!r}"
+        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!r} from {__name__!r}: {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx_openai/components/openai/openai.py

@@ -0,0 +1,99 @@
+from langchain_openai import OpenAIEmbeddings
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
+from lfx.field_typing import Embeddings
+from lfx.io import BoolInput, DictInput, DropdownInput, FloatInput, IntInput, MessageTextInput, SecretStrInput
+
+
+class OpenAIEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "OpenAI Embeddings"
+    description = "Generate embeddings using OpenAI models."
+    icon = "OpenAI"
+    name = "OpenAIEmbeddings"
+
+    inputs = [
+        DictInput(
+            name="default_headers",
+            display_name="Default Headers",
+            advanced=True,
+            info="Default headers to use for the API request.",
+        ),
+        DictInput(
+            name="default_query",
+            display_name="Default Query",
+            advanced=True,
+            info="Default query parameters to use for the API request.",
+        ),
+        IntInput(name="chunk_size", display_name="Chunk Size", advanced=True, value=1000),
+        MessageTextInput(name="client", display_name="Client", advanced=True),
+        MessageTextInput(name="deployment", display_name="Deployment", advanced=True),
+        IntInput(name="embedding_ctx_length", display_name="Embedding Context Length", advanced=True, value=1536),
+        IntInput(name="max_retries", display_name="Max Retries", value=3, advanced=True),
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            advanced=False,
+            options=OPENAI_EMBEDDING_MODEL_NAMES,
+            value="text-embedding-3-small",
+        ),
+        DictInput(name="model_kwargs", display_name="Model Kwargs", advanced=True),
+        SecretStrInput(name="openai_api_key", display_name="OpenAI API Key", value="OPENAI_API_KEY", required=True),
+        MessageTextInput(name="openai_api_base", display_name="OpenAI API Base", advanced=True),
+        MessageTextInput(name="openai_api_type", display_name="OpenAI API Type", advanced=True),
+        MessageTextInput(name="openai_api_version", display_name="OpenAI API Version", advanced=True),
+        MessageTextInput(
+            name="openai_organization",
+            display_name="OpenAI Organization",
+            advanced=True,
+        ),
+        MessageTextInput(name="openai_proxy", display_name="OpenAI Proxy", advanced=True),
+        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
+        BoolInput(name="show_progress_bar", display_name="Show Progress Bar", advanced=True),
+        BoolInput(name="skip_empty", display_name="Skip Empty", advanced=True),
+        MessageTextInput(
+            name="tiktoken_model_name",
+            display_name="TikToken Model Name",
+            advanced=True,
+        ),
+        BoolInput(
+            name="tiktoken_enable",
+            display_name="TikToken Enable",
+            advanced=True,
+            value=True,
+            info="If False, you must have transformers installed.",
+        ),
+        IntInput(
+            name="dimensions",
+            display_name="Dimensions",
+            info="The number of dimensions the resulting output embeddings should have. "
+            "Only supported by certain models.",
+            advanced=True,
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        return OpenAIEmbeddings(
+            client=self.client or None,
+            model=self.model,
+            dimensions=self.dimensions or None,
+            deployment=self.deployment or None,
+            api_version=self.openai_api_version or None,
+            base_url=self.openai_api_base or None,
+            openai_api_type=self.openai_api_type or None,
+            openai_proxy=self.openai_proxy or None,
+            embedding_ctx_length=self.embedding_ctx_length,
+            api_key=self.openai_api_key or None,
+            organization=self.openai_organization or None,
+            allowed_special="all",
+            disallowed_special="all",
+            chunk_size=self.chunk_size,
+            max_retries=self.max_retries,
+            timeout=self.request_timeout or None,
+            tiktoken_enabled=self.tiktoken_enable,
+            tiktoken_model_name=self.tiktoken_model_name or None,
+            show_progress_bar=self.show_progress_bar,
+            model_kwargs=self.model_kwargs,
+            skip_empty=self.skip_empty,
+            default_headers=self.default_headers or None,
+            default_query=self.default_query or None,
+        )

lfx_openai/components/openai/openai_chat_model.py

@@ -0,0 +1,176 @@
+from typing import Any
+
+from langchain_openai import ChatOpenAI
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES, OPENAI_REASONING_MODEL_NAMES
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput, DictInput, DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
+from lfx.log.logger import logger
+from lfx.utils.secrets import secret_value_to_str
+
+
+class OpenAIModelComponent(LCModelComponent):
+    display_name = "OpenAI"
+    description = "Generates text using OpenAI LLMs."
+    icon = "OpenAI"
+    name = "OpenAIModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
+            range_spec=RangeSpec(min=0, max=128000),
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            advanced=True,
+            info="If True, it will output JSON regardless of passing a schema.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
+            value=OPENAI_CHAT_MODEL_NAMES[0],
+            combobox=True,
+            real_time_refresh=True,
+        ),
+        StrInput(
+            name="openai_api_base",
+            display_name="OpenAI API Base",
+            advanced=True,
+            info="The base URL of the OpenAI API. "
+            "Defaults to https://api.openai.com/v1. "
+            "You can change this to use other APIs like JinaChat, LocalAI and Prem.",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="OpenAI API Key",
+            info="The OpenAI API Key to use for the OpenAI model.",
+            advanced=False,
+            value="OPENAI_API_KEY",
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            show=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+        IntInput(
+            name="max_retries",
+            display_name="Max Retries",
+            info="The maximum number of retries to make when generating.",
+            advanced=True,
+            value=5,
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            info="The timeout for requests to OpenAI completion API.",
+            advanced=True,
+            value=700,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        logger.debug(f"Executing request with model: {self.model_name}")
+        logger.debug(f"API key type: {type(self.api_key)}, value: {'***' if self.api_key else None}")
+        api_key_value = secret_value_to_str(self.api_key) if self.api_key else None
+        logger.debug(f"Final api_key_value type: {type(api_key_value)}, value: {'***' if api_key_value else None}")
+
+        # Handle model_kwargs and ensure api_key doesn't conflict
+        model_kwargs = self.model_kwargs or {}
+        # Remove api_key from model_kwargs if it exists to prevent conflicts
+        if "api_key" in model_kwargs:
+            logger.warning("api_key found in model_kwargs, removing to prevent conflicts")
+            model_kwargs = dict(model_kwargs)  # Make a copy
+            del model_kwargs["api_key"]
+
+        parameters = {
+            "api_key": api_key_value,
+            "model_name": self.model_name,
+            "max_tokens": self.max_tokens or None,
+            "model_kwargs": model_kwargs,
+            "base_url": self.openai_api_base or "https://api.openai.com/v1",
+            "max_retries": self.max_retries,
+            "timeout": self.timeout,
+        }
+
+        # TODO: Revisit if/once parameters are supported for reasoning models
+        unsupported_params_for_reasoning_models = ["temperature", "seed"]
+
+        if self.model_name not in OPENAI_REASONING_MODEL_NAMES:
+            parameters["temperature"] = self.temperature if self.temperature is not None else 0.1
+            parameters["seed"] = self.seed
+        else:
+            params_str = ", ".join(unsupported_params_for_reasoning_models)
+            logger.debug(f"{self.model_name} is a reasoning model, {params_str} are not configurable. Ignoring.")
+
+        parameters["stream_usage"] = True
+        output = ChatOpenAI(**parameters)
+        if self.json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output
+
+    def _get_exception_message(self, e: Exception):
+        """Get a message from an OpenAI exception.
+
+        Args:
+            e (Exception): The exception to get the message from.
+
+        Returns:
+            str: The message from the exception.
+        """
+        try:
+            from openai import BadRequestError, NotFoundError
+        except ImportError:
+            return None
+        if isinstance(e, NotFoundError):
+            body = getattr(e, "body", None) or {}
+            if isinstance(body, dict) and body.get("code") == "model_not_found":
+                return (
+                    f"Model '{self.model_name}' is not available for this OpenAI account. "
+                    "Your API tier may not have access yet — check "
+                    "https://platform.openai.com/settings/organization/limits "
+                    "or select a different model."
+                )
+        if isinstance(e, BadRequestError):
+            message = e.body.get("message")
+            if message:
+                return message
+        return None
+
+    def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
+        if field_name in {"base_url", "model_name", "api_key"} and field_value in OPENAI_REASONING_MODEL_NAMES:
+            build_config["temperature"]["show"] = False
+            build_config["seed"]["show"] = False
+            # Hide system_message for o1 models - currently unsupported
+            if field_value.startswith("o1") and "system_message" in build_config:
+                build_config["system_message"]["show"] = False
+        if field_name in {"base_url", "model_name", "api_key"} and field_value in OPENAI_CHAT_MODEL_NAMES:
+            build_config["temperature"]["show"] = True
+            build_config["seed"]["show"] = True
+            if "system_message" in build_config:
+                build_config["system_message"]["show"] = True
+        return build_config

lfx_openai/extension.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-openai",
+  "version": "0.1.0",
+  "name": "OpenAI",
+  "description": "OpenAI component(s) as a standalone Langflow Extension Bundle.",
+  "lfx": {
+    "compat": ["1"]
+  },
+  "bundles": [
+    {
+      "name": "openai",
+      "path": "components/openai"
+    }
+  ]
+}

lfx_openai-0.1.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: lfx-openai
+Version: 0.1.0
+Summary: OpenAI component(s) as a standalone Langflow Extension Bundle.
+Project-URL: Homepage, https://github.com/langflow-ai/langflow
+Project-URL: Documentation, https://docs.langflow.org/extensions
+Project-URL: Repository, https://github.com/langflow-ai/langflow
+Author-email: Langflow <contact@langflow.org>
+License: MIT
+Keywords: bundle,extension,langflow,lfx,openai
+Requires-Python: <3.15,>=3.10
+Requires-Dist: langchain-openai>=1.1.6
+Requires-Dist: lfx<2.0.0,>=1.11.0.dev0
+Requires-Dist: openai<3.0.0,>=1.68.2
+Description-Content-Type: text/markdown
+
+# lfx-openai
+
+OpenAI component(s) as a standalone Langflow Extension Bundle.
+
+## Install
+
+```bash
+pip install lfx-openai
+```
+
+The bundle is registered automatically via the `langflow.extensions`
+entry-point.  After install, restart your Langflow server; the bundle's
+components will appear in the palette under the `openai` group with
+the namespaced IDs `ext:openai:<Class>@official`.
+
+## Develop
+
+```bash
+cd src/bundles/openai
+pip install -e .
+lfx extension validate src/lfx_openai
+```
+
+## Migration
+
+Saved flows referencing the legacy class name(s) or the old import paths
+under `lfx.components.openai.*` are rewritten to the new namespaced
+IDs by the migration table in
+`src/lfx/src/lfx/extension/migration/migration_table.json`.

lfx_openai-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+lfx_openai/__init__.py,sha256=rEDy9B4Vr0kYT-XOoZ8t8xz281gYPFkJUuPTj4DSTFQ,494
+lfx_openai/extension.json,sha256=NjSx8mJIL34OmeyxbdAH7eOrQV33COvwlG0a3Wc2hSU,339
+lfx_openai/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lfx_openai/components/openai/__init__.py,sha256=-nelaqD6W1wIYNpTI426J6OmsRYxnUTfmpEu1q_VzQ8,1322
+lfx_openai/components/openai/openai.py,sha256=o-hNW7IwCTbUSCzxLx7daDWhGRQd94uBDKhMuU2PEto,4504
+lfx_openai/components/openai/openai_chat_model.py,sha256=TUmgkZQYvwFlXZRsbzEcS4TQ1PCGvgvOv4fel_XN6Xc,7154
+lfx_openai-0.1.0.dist-info/METADATA,sha256=gRQIswpxZh-EWFIFWau4jHEpP8mxcUZDg-9Ru15FkDQ,1344
+lfx_openai-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lfx_openai-0.1.0.dist-info/entry_points.txt,sha256=CW2uszG9B-E9USfGyobO0iltkzr2R6or65uVPYSx6-I,46
+lfx_openai-0.1.0.dist-info/RECORD,,

lfx_openai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

lfx_openai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[langflow.extensions]
+lfx-openai = lfx_openai