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

langflow/components/google/google_generative_ai.py

@@ -1,147 +0,0 @@
-from typing import Any
-
-import requests
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
-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, FloatInput, IntInput, SecretStrInput, SliderInput
-from langflow.logging.logger import logger
-from langflow.schema.dotdict import dotdict
-
-
-class GoogleGenerativeAIComponent(LCModelComponent):
-    display_name = "Google Generative AI"
-    description = "Generate text using Google Generative AI."
-    icon = "GoogleGenerativeAI"
-    name = "GoogleGenerativeAIModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        IntInput(
-            name="max_output_tokens", display_name="Max Output Tokens", info="The maximum number of tokens to generate."
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model",
-            info="The name of the model to use.",
-            options=GOOGLE_GENERATIVE_AI_MODELS,
-            value="gemini-1.5-pro",
-            refresh_button=True,
-            combobox=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="Google API Key",
-            info="The Google API Key to use for the Google Generative AI.",
-            required=True,
-            real_time_refresh=True,
-        ),
-        FloatInput(
-            name="top_p",
-            display_name="Top P",
-            info="The maximum cumulative probability of tokens to consider when sampling.",
-            advanced=True,
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
-        ),
-        IntInput(
-            name="n",
-            display_name="N",
-            info="Number of chat completions to generate for each prompt. "
-            "Note that the API may not return the full n completions if duplicates are generated.",
-            advanced=True,
-        ),
-        IntInput(
-            name="top_k",
-            display_name="Top K",
-            info="Decode using top-k sampling: consider the set of top_k most probable tokens. Must be positive.",
-            advanced=True,
-        ),
-        BoolInput(
-            name="tool_model_enabled",
-            display_name="Tool Model Enabled",
-            info="Whether to use the tool model.",
-            value=False,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        try:
-            from langchain_google_genai import ChatGoogleGenerativeAI
-        except ImportError as e:
-            msg = "The 'langchain_google_genai' package is required to use the Google Generative AI model."
-            raise ImportError(msg) from e
-
-        google_api_key = self.api_key
-        model = self.model_name
-        max_output_tokens = self.max_output_tokens
-        temperature = self.temperature
-        top_k = self.top_k
-        top_p = self.top_p
-        n = self.n
-
-        return ChatGoogleGenerativeAI(
-            model=model,
-            max_output_tokens=max_output_tokens or None,
-            temperature=temperature,
-            top_k=top_k or None,
-            top_p=top_p or None,
-            n=n or 1,
-            google_api_key=SecretStr(google_api_key).get_secret_value(),
-        )
-
-    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
-        try:
-            import google.generativeai as genai
-
-            genai.configure(api_key=self.api_key)
-            model_ids = [
-                model.name.replace("models/", "")
-                for model in genai.list_models()
-                if "generateContent" in model.supported_generation_methods
-            ]
-            model_ids.sort(reverse=True)
-        except (ImportError, ValueError) as e:
-            logger.exception(f"Error getting model names: {e}")
-            model_ids = GOOGLE_GENERATIVE_AI_MODELS
-        if tool_model_enabled:
-            try:
-                from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
-            except ImportError as e:
-                msg = "langchain_google_genai is not installed."
-                raise ImportError(msg) from e
-            for model in model_ids:
-                model_with_tool = ChatGoogleGenerativeAI(
-                    model=self.model_name,
-                    google_api_key=self.api_key,
-                )
-                if not self.supports_tool_calling(model_with_tool):
-                    model_ids.remove(model)
-        return model_ids
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
-            try:
-                if len(self.api_key) == 0:
-                    ids = GOOGLE_GENERATIVE_AI_MODELS
-                else:
-                    try:
-                        ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
-                    except (ImportError, ValueError, requests.exceptions.RequestException) as e:
-                        logger.exception(f"Error getting model names: {e}")
-                        ids = GOOGLE_GENERATIVE_AI_MODELS
-                build_config.setdefault("model_name", {})
-                build_config["model_name"]["options"] = ids
-                build_config["model_name"].setdefault("value", ids[0])
-            except Exception as e:
-                msg = f"Error getting model names: {e}"
-                raise ValueError(msg) from e
-        return build_config

langflow/components/google/google_generative_ai_embeddings.py

@@ -1,141 +0,0 @@
-# from langflow.field_typing import Data
-
-# TODO: remove ignore once the google package is published with types
-from google.ai.generativelanguage_v1beta.types import BatchEmbedContentsRequest
-from langchain_core.embeddings import Embeddings
-from langchain_google_genai import GoogleGenerativeAIEmbeddings
-from langchain_google_genai._common import GoogleGenerativeAIError
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output, SecretStrInput
-
-MIN_DIMENSION_ERROR = "Output dimensionality must be at least 1"
-MAX_DIMENSION_ERROR = (
-    "Output dimensionality cannot exceed 768. Google's embedding models only support dimensions up to 768."
-)
-MAX_DIMENSION = 768
-MIN_DIMENSION = 1
-
-
-class GoogleGenerativeAIEmbeddingsComponent(Component):
-    display_name = "Google Generative AI Embeddings"
-    description = (
-        "Connect to Google's generative AI embeddings service using the GoogleGenerativeAIEmbeddings class, "
-        "found in the langchain-google-genai package."
-    )
-    documentation: str = "https://python.langchain.com/v0.2/docs/integrations/text_embedding/google_generative_ai/"
-    icon = "GoogleGenerativeAI"
-    name = "Google Generative AI Embeddings"
-
-    inputs = [
-        SecretStrInput(name="api_key", display_name="API Key", required=True),
-        MessageTextInput(name="model_name", display_name="Model Name", value="models/text-embedding-004"),
-    ]
-
-    outputs = [
-        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
-    ]
-
-    def build_embeddings(self) -> Embeddings:
-        if not self.api_key:
-            msg = "API Key is required"
-            raise ValueError(msg)
-
-        class HotaGoogleGenerativeAIEmbeddings(GoogleGenerativeAIEmbeddings):
-            def __init__(self, *args, **kwargs) -> None:
-                super(GoogleGenerativeAIEmbeddings, self).__init__(*args, **kwargs)
-
-            def embed_documents(
-                self,
-                texts: list[str],
-                *,
-                batch_size: int = 100,
-                task_type: str | None = None,
-                titles: list[str] | None = None,
-                output_dimensionality: int | None = 768,
-            ) -> list[list[float]]:
-                """Embed a list of strings.
-
-                Google Generative AI currently sets a max batch size of 100 strings.
-
-                Args:
-                    texts: List[str] The list of strings to embed.
-                    batch_size: [int] The batch size of embeddings to send to the model
-                    task_type: task_type (https://ai.google.dev/api/rest/v1/TaskType)
-                    titles: An optional list of titles for texts provided.
-                    Only applicable when TaskType is RETRIEVAL_DOCUMENT.
-                    output_dimensionality: Optional reduced dimension for the output embedding.
-                    https://ai.google.dev/api/rest/v1/models/batchEmbedContents#EmbedContentRequest
-                Returns:
-                    List of embeddings, one for each text.
-                """
-                if output_dimensionality is not None and output_dimensionality < MIN_DIMENSION:
-                    raise ValueError(MIN_DIMENSION_ERROR)
-                if output_dimensionality is not None and output_dimensionality > MAX_DIMENSION:
-                    error_msg = MAX_DIMENSION_ERROR.format(output_dimensionality)
-                    raise ValueError(error_msg)
-
-                embeddings: list[list[float]] = []
-                batch_start_index = 0
-                for batch in GoogleGenerativeAIEmbeddings._prepare_batches(texts, batch_size):
-                    if titles:
-                        titles_batch = titles[batch_start_index : batch_start_index + len(batch)]
-                        batch_start_index += len(batch)
-                    else:
-                        titles_batch = [None] * len(batch)  # type: ignore[list-item]
-
-                    requests = [
-                        self._prepare_request(
-                            text=text,
-                            task_type=task_type,
-                            title=title,
-                            output_dimensionality=output_dimensionality,
-                        )
-                        for text, title in zip(batch, titles_batch, strict=True)
-                    ]
-
-                    try:
-                        result = self.client.batch_embed_contents(
-                            BatchEmbedContentsRequest(requests=requests, model=self.model)
-                        )
-                    except Exception as e:
-                        msg = f"Error embedding content: {e}"
-                        raise GoogleGenerativeAIError(msg) from e
-                    embeddings.extend([list(e.values) for e in result.embeddings])
-                return embeddings
-
-            def embed_query(
-                self,
-                text: str,
-                task_type: str | None = None,
-                title: str | None = None,
-                output_dimensionality: int | None = 768,
-            ) -> list[float]:
-                """Embed a text.
-
-                Args:
-                    text: The text to embed.
-                    task_type: task_type (https://ai.google.dev/api/rest/v1/TaskType)
-                    title: An optional title for the text.
-                    Only applicable when TaskType is RETRIEVAL_DOCUMENT.
-                    output_dimensionality: Optional reduced dimension for the output embedding.
-                    https://ai.google.dev/api/rest/v1/models/batchEmbedContents#EmbedContentRequest
-
-                Returns:
-                    Embedding for the text.
-                """
-                if output_dimensionality is not None and output_dimensionality < MIN_DIMENSION:
-                    raise ValueError(MIN_DIMENSION_ERROR)
-                if output_dimensionality is not None and output_dimensionality > MAX_DIMENSION:
-                    error_msg = MAX_DIMENSION_ERROR.format(output_dimensionality)
-                    raise ValueError(error_msg)
-
-                task_type = task_type or "RETRIEVAL_QUERY"
-                return self.embed_documents(
-                    [text],
-                    task_type=task_type,
-                    titles=[title] if title else None,
-                    output_dimensionality=output_dimensionality,
-                )[0]
-
-        return HotaGoogleGenerativeAIEmbeddings(model=self.model_name, google_api_key=self.api_key)

langflow/components/google/google_oauth_token.py

@@ -1,89 +0,0 @@
-import json
-import re
-from pathlib import Path
-
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import FileInput, MultilineInput, Output
-from langflow.schema.data import Data
-
-
-class GoogleOAuthToken(Component):
-    display_name = "Google OAuth Token"
-    description = "Generates a JSON string with your Google OAuth token."
-    documentation: str = "https://developers.google.com/identity/protocols/oauth2/web-server?hl=pt-br#python_1"
-    icon = "Google"
-    name = "GoogleOAuthToken"
-    legacy: bool = True
-    inputs = [
-        MultilineInput(
-            name="scopes",
-            display_name="Scopes",
-            info="Input scopes for your application.",
-            required=True,
-        ),
-        FileInput(
-            name="oauth_credentials",
-            display_name="Credentials File",
-            info="Input OAuth Credentials file (e.g. credentials.json).",
-            file_types=["json"],
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Output", name="output", method="build_output"),
-    ]
-
-    def validate_scopes(self, scopes):
-        pattern = (
-            r"^(https://www\.googleapis\.com/auth/[\w\.\-]+"
-            r"|mail\.google\.com/"
-            r"|www\.google\.com/calendar/feeds"
-            r"|www\.google\.com/m8/feeds)"
-            r"(,\s*https://www\.googleapis\.com/auth/[\w\.\-]+"
-            r"|mail\.google\.com/"
-            r"|www\.google\.com/calendar/feeds"
-            r"|www\.google\.com/m8/feeds)*$"
-        )
-        if not re.match(pattern, scopes):
-            error_message = "Invalid scope format."
-            raise ValueError(error_message)
-
-    def build_output(self) -> Data:
-        self.validate_scopes(self.scopes)
-
-        user_scopes = [scope.strip() for scope in self.scopes.split(",")]
-        if self.scopes:
-            scopes = user_scopes
-        else:
-            error_message = "Incorrect scope, check the scopes field."
-            raise ValueError(error_message)
-
-        creds = None
-        token_path = Path("token.json")
-
-        if token_path.exists():
-            creds = Credentials.from_authorized_user_file(str(token_path), scopes)
-
-        if not creds or not creds.valid:
-            if creds and creds.expired and creds.refresh_token:
-                creds.refresh(Request())
-            else:
-                if self.oauth_credentials:
-                    client_secret_file = self.oauth_credentials
-                else:
-                    error_message = "OAuth 2.0 Credentials file not provided."
-                    raise ValueError(error_message)
-
-                flow = InstalledAppFlow.from_client_secrets_file(client_secret_file, scopes)
-                creds = flow.run_local_server(port=0)
-
-                token_path.write_text(creds.to_json(), encoding="utf-8")
-
-        creds_json = json.loads(creds.to_json())
-
-        return Data(data=creds_json)

langflow/components/google/google_search_api_core.py

@@ -1,68 +0,0 @@
-from langchain_google_community import GoogleSearchAPIWrapper
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import IntInput, MultilineInput, Output, SecretStrInput
-from langflow.schema.dataframe import DataFrame
-
-
-class GoogleSearchAPICore(Component):
-    display_name = "Google Search API"
-    description = "Call Google Search API and return results as a DataFrame."
-    icon = "Google"
-
-    inputs = [
-        SecretStrInput(
-            name="google_api_key",
-            display_name="Google API Key",
-            required=True,
-        ),
-        SecretStrInput(
-            name="google_cse_id",
-            display_name="Google CSE ID",
-            required=True,
-        ),
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-            tool_mode=True,
-        ),
-        IntInput(
-            name="k",
-            display_name="Number of results",
-            value=4,
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Results",
-            name="results",
-            type_=DataFrame,
-            method="search_google",
-        ),
-    ]
-
-    def search_google(self) -> DataFrame:
-        """Search Google using the provided query."""
-        if not self.google_api_key:
-            return DataFrame([{"error": "Invalid Google API Key"}])
-
-        if not self.google_cse_id:
-            return DataFrame([{"error": "Invalid Google CSE ID"}])
-
-        try:
-            wrapper = GoogleSearchAPIWrapper(
-                google_api_key=self.google_api_key, google_cse_id=self.google_cse_id, k=self.k
-            )
-            results = wrapper.results(query=self.input_value, num_results=self.k)
-            return DataFrame(results)
-        except (ValueError, KeyError) as e:
-            return DataFrame([{"error": f"Invalid configuration: {e!s}"}])
-        except ConnectionError as e:
-            return DataFrame([{"error": f"Connection error: {e!s}"}])
-        except RuntimeError as e:
-            return DataFrame([{"error": f"Error occurred while searching: {e!s}"}])
-
-    def build(self):
-        return self.search_google

langflow/components/google/google_serper_api_core.py

@@ -1,74 +0,0 @@
-from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import IntInput, MultilineInput, Output, SecretStrInput
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.message import Message
-
-
-class GoogleSerperAPICore(Component):
-    display_name = "Google Serper API"
-    description = "Call the Serper.dev Google Search API."
-    icon = "Serper"
-
-    inputs = [
-        SecretStrInput(
-            name="serper_api_key",
-            display_name="Serper API Key",
-            required=True,
-        ),
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-            tool_mode=True,
-        ),
-        IntInput(
-            name="k",
-            display_name="Number of results",
-            value=4,
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Results",
-            name="results",
-            type_=DataFrame,
-            method="search_serper",
-        ),
-    ]
-
-    def search_serper(self) -> DataFrame:
-        try:
-            wrapper = self._build_wrapper()
-            results = wrapper.results(query=self.input_value)
-            list_results = results.get("organic", [])
-
-            # Convert results to DataFrame using list comprehension
-            df_data = [
-                {
-                    "title": result.get("title", ""),
-                    "link": result.get("link", ""),
-                    "snippet": result.get("snippet", ""),
-                }
-                for result in list_results
-            ]
-
-            return DataFrame(df_data)
-        except (ValueError, KeyError, ConnectionError) as e:
-            error_message = f"Error occurred while searching: {e!s}"
-            self.status = error_message
-            # Return DataFrame with error as a list of dictionaries
-            return DataFrame([{"error": error_message}])
-
-    def text_search_serper(self) -> Message:
-        search_results = self.search_serper()
-        text_result = search_results.to_string(index=False) if not search_results.empty else "No results found."
-        return Message(text=text_result)
-
-    def _build_wrapper(self):
-        return GoogleSerperAPIWrapper(serper_api_key=self.serper_api_key, k=self.k)
-
-    def build(self):
-        return self.search_serper

langflow/components/groq/__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 .groq import GroqModel
-
-_dynamic_imports = {
-    "GroqModel": "groq",
-}
-
-__all__ = [
-    "GroqModel",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import groq 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__)