langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/huggingface/huggingface_inference_api.py

@@ -1,106 +0,0 @@
-from urllib.parse import urlparse
-
-import requests
-from langchain_community.embeddings.huggingface import HuggingFaceInferenceAPIEmbeddings
-
-# Next update: use langchain_huggingface
-from pydantic import SecretStr
-from tenacity import retry, stop_after_attempt, wait_fixed
-
-from langflow.base.embeddings.model import LCEmbeddingsModel
-from langflow.field_typing import Embeddings
-from langflow.io import MessageTextInput, Output, SecretStrInput
-
-
-class HuggingFaceInferenceAPIEmbeddingsComponent(LCEmbeddingsModel):
-    display_name = "Hugging Face Embeddings Inference"
-    description = "Generate embeddings using Hugging Face Text Embeddings Inference (TEI)"
-    documentation = "https://huggingface.co/docs/text-embeddings-inference/index"
-    icon = "HuggingFace"
-    name = "HuggingFaceInferenceAPIEmbeddings"
-
-    inputs = [
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            advanced=False,
-            info="Required for non-local inference endpoints. Local inference does not require an API Key.",
-        ),
-        MessageTextInput(
-            name="inference_endpoint",
-            display_name="Inference Endpoint",
-            required=True,
-            value="https://api-inference.huggingface.co/models/",
-            info="Custom inference endpoint URL.",
-        ),
-        MessageTextInput(
-            name="model_name",
-            display_name="Model Name",
-            value="BAAI/bge-large-en-v1.5",
-            info="The name of the model to use for text embeddings.",
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
-    ]
-
-    def validate_inference_endpoint(self, inference_endpoint: str) -> bool:
-        parsed_url = urlparse(inference_endpoint)
-        if not all([parsed_url.scheme, parsed_url.netloc]):
-            msg = (
-                f"Invalid inference endpoint format: '{self.inference_endpoint}'. "
-                "Please ensure the URL includes both a scheme (e.g., 'http://' or 'https://') and a domain name. "
-                "Example: 'http://localhost:8080' or 'https://api.example.com'"
-            )
-            raise ValueError(msg)
-
-        try:
-            response = requests.get(f"{inference_endpoint}/health", timeout=5)
-        except requests.RequestException as e:
-            msg = (
-                f"Inference endpoint '{inference_endpoint}' is not responding. "
-                "Please ensure the URL is correct and the service is running."
-            )
-            raise ValueError(msg) from e
-
-        if response.status_code != requests.codes.ok:
-            msg = f"Hugging Face health check failed: {response.status_code}"
-            raise ValueError(msg)
-        # returning True to solve linting error
-        return True
-
-    def get_api_url(self) -> str:
-        if "huggingface" in self.inference_endpoint.lower():
-            return f"{self.inference_endpoint}"
-        return self.inference_endpoint
-
-    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-    def create_huggingface_embeddings(
-        self, api_key: SecretStr, api_url: str, model_name: str
-    ) -> HuggingFaceInferenceAPIEmbeddings:
-        return HuggingFaceInferenceAPIEmbeddings(api_key=api_key, api_url=api_url, model_name=model_name)
-
-    def build_embeddings(self) -> Embeddings:
-        api_url = self.get_api_url()
-
-        is_local_url = (
-            api_url.startswith(("http://localhost", "http://127.0.0.1", "http://0.0.0.0", "http://docker"))
-            or "huggingface.co" not in api_url.lower()
-        )
-
-        if not self.api_key and is_local_url:
-            self.validate_inference_endpoint(api_url)
-            api_key = SecretStr("APIKeyForLocalDeployment")
-        elif not self.api_key:
-            msg = "API Key is required for non-local inference endpoints"
-            raise ValueError(msg)
-        else:
-            api_key = SecretStr(self.api_key).get_secret_value()
-
-        try:
-            return self.create_huggingface_embeddings(api_key, api_url, self.model_name)
-        except Exception as e:
-            msg = "Could not connect to Hugging Face Inference API."
-            raise ValueError(msg) from e

langflow/components/ibm/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.ibm.watsonx import WatsonxAIComponent
-    from langflow.components.ibm.watsonx_embeddings import WatsonxEmbeddingsComponent
-
-_dynamic_imports = {
-    "WatsonxAIComponent": "watsonx",
-    "WatsonxEmbeddingsComponent": "watsonx_embeddings",
-}
-
-__all__ = ["WatsonxAIComponent", "WatsonxEmbeddingsComponent"]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import ibm 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__)

langflow/components/ibm/watsonx.py

@@ -1,203 +0,0 @@
-import json
-from typing import Any
-
-import requests
-from langchain_ibm import ChatWatsonx
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
-from langflow.logging.logger import logger
-from langflow.schema.dotdict import dotdict
-
-
-class WatsonxAIComponent(LCModelComponent):
-    display_name = "IBM watsonx.ai"
-    description = "Generate text using IBM watsonx.ai foundation models."
-    icon = "WatsonxAI"
-    name = "IBMwatsonxModel"
-    beta = False
-
-    _default_models = ["ibm/granite-3-2b-instruct", "ibm/granite-3-8b-instruct", "ibm/granite-13b-instruct-v2"]
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        DropdownInput(
-            name="url",
-            display_name="watsonx API Endpoint",
-            info="The base URL of the API.",
-            value=None,
-            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,
-        ),
-        StrInput(
-            name="project_id",
-            display_name="watsonx Project ID",
-            required=True,
-            info="The project ID or deployment space ID that is associated with the foundation model.",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            info="The API Key to use for the model.",
-            required=True,
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            options=[],
-            value=None,
-            dynamic=True,
-            required=True,
-        ),
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            advanced=True,
-            info="The maximum number of tokens to generate.",
-            range_spec=RangeSpec(min=1, max=4096),
-            value=1000,
-        ),
-        StrInput(
-            name="stop_sequence",
-            display_name="Stop Sequence",
-            advanced=True,
-            info="Sequence where generation should stop.",
-            field_type="str",
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            info="Controls randomness, higher values increase diversity.",
-            value=0.1,
-            range_spec=RangeSpec(min=0, max=2, step=0.01),
-            advanced=True,
-        ),
-        SliderInput(
-            name="top_p",
-            display_name="Top P",
-            info="The cumulative probability cutoff for token selection. "
-            "Lower values mean sampling from a smaller, more top-weighted nucleus.",
-            value=0.9,
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            advanced=True,
-        ),
-        SliderInput(
-            name="frequency_penalty",
-            display_name="Frequency Penalty",
-            info="Penalty for frequency of token usage.",
-            value=0.5,
-            range_spec=RangeSpec(min=-2.0, max=2.0, step=0.01),
-            advanced=True,
-        ),
-        SliderInput(
-            name="presence_penalty",
-            display_name="Presence Penalty",
-            info="Penalty for token presence in prior text.",
-            value=0.3,
-            range_spec=RangeSpec(min=-2.0, max=2.0, step=0.01),
-            advanced=True,
-        ),
-        IntInput(
-            name="seed",
-            display_name="Random Seed",
-            advanced=True,
-            info="The random seed for the model.",
-            value=8,
-        ),
-        BoolInput(
-            name="logprobs",
-            display_name="Log Probabilities",
-            advanced=True,
-            info="Whether to return log probabilities of the output tokens.",
-            value=True,
-        ),
-        IntInput(
-            name="top_logprobs",
-            display_name="Top Log Probabilities",
-            advanced=True,
-            info="Number of most likely tokens to return at each position.",
-            value=3,
-            range_spec=RangeSpec(min=1, max=20),
-        ),
-        StrInput(
-            name="logit_bias",
-            display_name="Logit Bias",
-            advanced=True,
-            info='JSON string of token IDs to bias or suppress (e.g., {"1003": -100, "1004": 100}).',
-            field_type="str",
-        ),
-    ]
-
-    @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 Exception:  # noqa: BLE001
-            logger.exception("Error fetching models. Using default models.")
-            return WatsonxAIComponent._default_models
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        """Update model options when URL or API key changes."""
-        logger.info("Updating build config. Field name: %s, Field value: %s", field_name, field_value)
-
-        if field_name == "url" and field_value:
-            try:
-                models = self.fetch_models(base_url=build_config.url.value)
-                build_config.model_name.options = models
-                if build_config.model_name.value:
-                    build_config.model_name.value = models[0]
-                info_message = f"Updated model options: {len(models)} models found in {build_config.url.value}"
-                logger.info(info_message)
-            except Exception:  # noqa: BLE001
-                logger.exception("Error updating model options.")
-
-    def build_model(self) -> LanguageModel:
-        # Parse logit_bias from JSON string if provided
-        logit_bias = None
-        if hasattr(self, "logit_bias") and self.logit_bias:
-            try:
-                logit_bias = json.loads(self.logit_bias)
-            except json.JSONDecodeError:
-                logger.warning("Invalid logit_bias JSON format. Using default instead.")
-                logit_bias = {"1003": -100, "1004": -100}
-
-        chat_params = {
-            "max_tokens": getattr(self, "max_tokens", None),
-            "temperature": getattr(self, "temperature", None),
-            "top_p": getattr(self, "top_p", None),
-            "frequency_penalty": getattr(self, "frequency_penalty", None),
-            "presence_penalty": getattr(self, "presence_penalty", None),
-            "seed": getattr(self, "seed", None),
-            "stop": [self.stop_sequence] if self.stop_sequence else [],
-            "n": 1,
-            "logprobs": getattr(self, "logprobs", True),
-            "top_logprobs": getattr(self, "top_logprobs", None),
-            "time_limit": 600000,
-            "logit_bias": logit_bias,
-        }
-
-        return ChatWatsonx(
-            apikey=SecretStr(self.api_key).get_secret_value(),
-            url=self.url,
-            project_id=self.project_id,
-            model_id=self.model_name,
-            params=chat_params,
-            streaming=self.stream,
-        )

langflow/components/ibm/watsonx_embeddings.py

@@ -1,135 +0,0 @@
-from typing import Any
-
-import requests
-from ibm_watsonx_ai import APIClient, Credentials
-from ibm_watsonx_ai.metanames import EmbedTextParamsMetaNames
-from langchain_ibm import WatsonxEmbeddings
-from pydantic.v1 import SecretStr
-
-from langflow.base.embeddings.model import LCEmbeddingsModel
-from langflow.field_typing import Embeddings
-from langflow.io import BoolInput, DropdownInput, IntInput, SecretStrInput, StrInput
-from langflow.logging.logger import logger
-from langflow.schema.dotdict import dotdict
-
-
-class WatsonxEmbeddingsComponent(LCEmbeddingsModel):
-    display_name = "IBM watsonx.ai Embeddings"
-    description = "Generate embeddings using IBM watsonx.ai models."
-    icon = "WatsonxAI"
-    name = "WatsonxEmbeddingsComponent"
-
-    # models present in all the regions
-    _default_models = [
-        "sentence-transformers/all-minilm-l12-v2",
-        "ibm/slate-125m-english-rtrvr-v2",
-        "ibm/slate-30m-english-rtrvr-v2",
-        "intfloat/multilingual-e5-large",
-    ]
-
-    inputs = [
-        DropdownInput(
-            name="url",
-            display_name="watsonx API Endpoint",
-            info="The base URL of the API.",
-            value=None,
-            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,
-        ),
-        StrInput(
-            name="project_id",
-            display_name="watsonx project id",
-            info="The project ID or deployment space ID that is associated with the foundation model.",
-            required=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            info="The API Key to use for the model.",
-            required=True,
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            options=[],
-            value=None,
-            dynamic=True,
-            required=True,
-        ),
-        IntInput(
-            name="truncate_input_tokens",
-            display_name="Truncate Input Tokens",
-            advanced=True,
-            value=200,
-        ),
-        BoolInput(
-            name="input_text",
-            display_name="Include the original text in the output",
-            value=True,
-            advanced=True,
-        ),
-    ]
-
-    @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_embedding,!lifecycle_withdrawn:and",
-            }
-            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 Exception:  # noqa: BLE001
-            logger.exception("Error fetching models")
-            return WatsonxEmbeddingsComponent._default_models
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        """Update model options when URL or API key changes."""
-        logger.debug(
-            "Updating build config. Field name: %s, Field value: %s",
-            field_name,
-            field_value,
-        )
-
-        if field_name == "url" and field_value:
-            try:
-                models = self.fetch_models(base_url=build_config.url.value)
-                build_config.model_name.options = models
-                if build_config.model_name.value:
-                    build_config.model_name.value = models[0]
-                info_message = f"Updated model options: {len(models)} models found in {build_config.url.value}"
-                logger.info(info_message)
-            except Exception:  # noqa: BLE001
-                logger.exception("Error updating model options.")
-
-    def build_embeddings(self) -> Embeddings:
-        credentials = Credentials(
-            api_key=SecretStr(self.api_key).get_secret_value(),
-            url=self.url,
-        )
-
-        api_client = APIClient(credentials)
-
-        params = {
-            EmbedTextParamsMetaNames.TRUNCATE_INPUT_TOKENS: self.truncate_input_tokens,
-            EmbedTextParamsMetaNames.RETURN_OPTIONS: {"input_text": self.input_text},
-        }
-
-        return WatsonxEmbeddings(
-            model_id=self.model_name,
-            params=params,
-            watsonx_client=api_client,
-            project_id=self.project_id,
-        )

langflow/components/icosacomputing/__init__.py

@@ -1,5 +0,0 @@
-from .combinatorial_reasoner import CombinatorialReasonerComponent
-
-__all__ = [
-    "CombinatorialReasonerComponent",
-]

langflow/components/icosacomputing/combinatorial_reasoner.py

@@ -1,84 +0,0 @@
-import requests
-from requests.auth import HTTPBasicAuth
-
-from langflow.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DropdownInput, SecretStrInput, StrInput
-from langflow.io import MessageTextInput, Output
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-
-
-class CombinatorialReasonerComponent(Component):
-    display_name = "Combinatorial Reasoner"
-    description = "Uses Combinatorial Optimization to construct an optimal prompt with embedded reasons. Sign up here:\nhttps://forms.gle/oWNv2NKjBNaqqvCx6"
-    icon = "Icosa"
-    name = "Combinatorial Reasoner"
-
-    inputs = [
-        MessageTextInput(name="prompt", display_name="Prompt", required=True),
-        SecretStrInput(
-            name="openai_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,
-        ),
-        StrInput(
-            name="username",
-            display_name="Username",
-            info="Username to authenticate access to Icosa CR API",
-            advanced=False,
-            required=True,
-        ),
-        SecretStrInput(
-            name="password",
-            display_name="Password",
-            info="Password to authenticate access to Icosa CR API.",
-            advanced=False,
-            required=True,
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            advanced=False,
-            options=OPENAI_CHAT_MODEL_NAMES,
-            value=OPENAI_CHAT_MODEL_NAMES[0],
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Optimized Prompt",
-            name="optimized_prompt",
-            method="build_prompt",
-        ),
-        Output(display_name="Selected Reasons", name="reasons", method="build_reasons"),
-    ]
-
-    def build_prompt(self) -> Message:
-        params = {
-            "prompt": self.prompt,
-            "apiKey": self.openai_api_key,
-            "model": self.model_name,
-        }
-
-        creds = HTTPBasicAuth(self.username, password=self.password)
-        response = requests.post(
-            "https://cr-api.icosacomputing.com/cr/langflow",
-            json=params,
-            auth=creds,
-            timeout=100,
-        )
-        response.raise_for_status()
-
-        prompt = response.json()["prompt"]
-
-        self.reasons = response.json()["finalReasons"]
-        return prompt
-
-    def build_reasons(self) -> Data:
-        # list of selected reasons
-        final_reasons = [reason[0] for reason in self.reasons]
-        return Data(value=final_reasons)

langflow/components/input_output/__init__.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.input_output.chat import ChatInput
-    from langflow.components.input_output.chat_output import ChatOutput
-    from langflow.components.input_output.text import TextInputComponent
-    from langflow.components.input_output.text_output import TextOutputComponent
-
-_dynamic_imports = {
-    "ChatInput": "chat",
-    "ChatOutput": "chat_output",
-    "TextInputComponent": "text",
-    "TextOutputComponent": "text_output",
-}
-
-__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent"]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import input/output 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__)