lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/amazon/amazon_bedrock_embedding.py

@@ -0,0 +1,109 @@
+from lfx.base.models.aws_constants import AWS_EMBEDDING_MODEL_IDS, AWS_REGIONS
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.inputs.inputs import SecretStrInput
+from lfx.io import DropdownInput, MessageTextInput, Output
+
+
+class AmazonBedrockEmbeddingsComponent(LCModelComponent):
+    display_name: str = "Amazon Bedrock Embeddings"
+    description: str = "Generate embeddings using Amazon Bedrock models."
+    icon = "Amazon"
+    name = "AmazonBedrockEmbeddings"
+
+    inputs = [
+        DropdownInput(
+            name="model_id",
+            display_name="Model Id",
+            options=AWS_EMBEDDING_MODEL_IDS,
+            value="amazon.titan-embed-text-v1",
+        ),
+        SecretStrInput(
+            name="aws_access_key_id",
+            display_name="AWS Access Key ID",
+            info="The access key for your AWS account."
+            "Usually set in Python code as the environment variable 'AWS_ACCESS_KEY_ID'.",
+            value="AWS_ACCESS_KEY_ID",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_secret_access_key",
+            display_name="AWS Secret Access Key",
+            info="The secret key for your AWS account. "
+            "Usually set in Python code as the environment variable 'AWS_SECRET_ACCESS_KEY'.",
+            value="AWS_SECRET_ACCESS_KEY",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_session_token",
+            display_name="AWS Session Token",
+            advanced=False,
+            info="The session key for your AWS account. "
+            "Only needed for temporary credentials. "
+            "Usually set in Python code as the environment variable 'AWS_SESSION_TOKEN'.",
+            value="AWS_SESSION_TOKEN",
+        ),
+        SecretStrInput(
+            name="credentials_profile_name",
+            display_name="Credentials Profile Name",
+            advanced=True,
+            info="The name of the profile to use from your "
+            "~/.aws/credentials file. "
+            "If not provided, the default profile will be used.",
+            value="AWS_CREDENTIALS_PROFILE_NAME",
+        ),
+        DropdownInput(
+            name="region_name",
+            display_name="Region Name",
+            value="us-east-1",
+            options=AWS_REGIONS,
+            info="The AWS region where your Bedrock resources are located.",
+        ),
+        MessageTextInput(
+            name="endpoint_url",
+            display_name="Endpoint URL",
+            advanced=True,
+            info="The URL of the AWS Bedrock endpoint to use.",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            from langchain_aws import BedrockEmbeddings
+        except ImportError as e:
+            msg = "langchain_aws is not installed. Please install it with `pip install langchain_aws`."
+            raise ImportError(msg) from e
+        try:
+            import boto3
+        except ImportError as e:
+            msg = "boto3 is not installed. Please install it with `pip install boto3`."
+            raise ImportError(msg) from e
+        if self.aws_access_key_id or self.aws_secret_access_key:
+            session = boto3.Session(
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                aws_session_token=self.aws_session_token,
+            )
+        elif self.credentials_profile_name:
+            session = boto3.Session(profile_name=self.credentials_profile_name)
+        else:
+            session = boto3.Session()
+
+        client_params = {}
+        if self.endpoint_url:
+            client_params["endpoint_url"] = self.endpoint_url
+        if self.region_name:
+            client_params["region_name"] = self.region_name
+
+        boto3_client = session.client("bedrock-runtime", **client_params)
+        return BedrockEmbeddings(
+            credentials_profile_name=self.credentials_profile_name,
+            client=boto3_client,
+            model_id=self.model_id,
+            endpoint_url=self.endpoint_url,
+            region_name=self.region_name,
+        )

lfx/components/amazon/amazon_bedrock_model.py

@@ -0,0 +1,130 @@
+from lfx.base.models.aws_constants import AWS_REGIONS, AWS_MODEL_IDs
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.inputs.inputs import MessageTextInput, SecretStrInput
+from lfx.io import DictInput, DropdownInput
+
+
+class AmazonBedrockComponent(LCModelComponent):
+    display_name: str = "Amazon Bedrock"
+    description: str = (
+        "Generate text using Amazon Bedrock LLMs with the legacy ChatBedrock API. "
+        "This component is deprecated. Please use Amazon Bedrock Converse instead "
+        "for better compatibility, newer features, and improved conversation handling."
+    )
+    icon = "Amazon"
+    name = "AmazonBedrockModel"
+    legacy = True
+    replacement = "amazon.AmazonBedrockConverseModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        DropdownInput(
+            name="model_id",
+            display_name="Model ID",
+            options=AWS_MODEL_IDs,
+            value="anthropic.claude-3-haiku-20240307-v1:0",
+            info="List of available model IDs to choose from.",
+        ),
+        SecretStrInput(
+            name="aws_access_key_id",
+            display_name="AWS Access Key ID",
+            info="The access key for your AWS account."
+            "Usually set in Python code as the environment variable 'AWS_ACCESS_KEY_ID'.",
+            value="AWS_ACCESS_KEY_ID",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_secret_access_key",
+            display_name="AWS Secret Access Key",
+            info="The secret key for your AWS account. "
+            "Usually set in Python code as the environment variable 'AWS_SECRET_ACCESS_KEY'.",
+            value="AWS_SECRET_ACCESS_KEY",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_session_token",
+            display_name="AWS Session Token",
+            advanced=False,
+            info="The session key for your AWS account. "
+            "Only needed for temporary credentials. "
+            "Usually set in Python code as the environment variable 'AWS_SESSION_TOKEN'.",
+            load_from_db=False,
+        ),
+        SecretStrInput(
+            name="credentials_profile_name",
+            display_name="Credentials Profile Name",
+            advanced=True,
+            info="The name of the profile to use from your "
+            "~/.aws/credentials file. "
+            "If not provided, the default profile will be used.",
+            load_from_db=False,
+        ),
+        DropdownInput(
+            name="region_name",
+            display_name="Region Name",
+            value="us-east-1",
+            options=AWS_REGIONS,
+            info="The AWS region where your Bedrock resources are located.",
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            is_list=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        MessageTextInput(
+            name="endpoint_url",
+            display_name="Endpoint URL",
+            advanced=True,
+            info="The URL of the Bedrock endpoint to use.",
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            from langchain_aws import ChatBedrock
+        except ImportError as e:
+            msg = "langchain_aws is not installed. Please install it with `pip install langchain_aws`."
+            raise ImportError(msg) from e
+        try:
+            import boto3
+        except ImportError as e:
+            msg = "boto3 is not installed. Please install it with `pip install boto3`."
+            raise ImportError(msg) from e
+        if self.aws_access_key_id or self.aws_secret_access_key:
+            try:
+                session = boto3.Session(
+                    aws_access_key_id=self.aws_access_key_id,
+                    aws_secret_access_key=self.aws_secret_access_key,
+                    aws_session_token=self.aws_session_token,
+                )
+            except Exception as e:
+                msg = "Could not create a boto3 session."
+                raise ValueError(msg) from e
+        elif self.credentials_profile_name:
+            session = boto3.Session(profile_name=self.credentials_profile_name)
+        else:
+            session = boto3.Session()
+
+        client_params = {}
+        if self.endpoint_url:
+            client_params["endpoint_url"] = self.endpoint_url
+        if self.region_name:
+            client_params["region_name"] = self.region_name
+
+        boto3_client = session.client("bedrock-runtime", **client_params)
+        try:
+            output = ChatBedrock(
+                client=boto3_client,
+                model_id=self.model_id,
+                region_name=self.region_name,
+                model_kwargs=self.model_kwargs,
+                endpoint_url=self.endpoint_url,
+                streaming=self.stream,
+            )
+        except Exception as e:
+            msg = "Could not connect to AmazonBedrock API."
+            raise ValueError(msg) from e
+        return output

lfx/components/amazon/s3_bucket_uploader.py

@@ -0,0 +1,211 @@
+from pathlib import Path
+from typing import Any
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import (
+    BoolInput,
+    DropdownInput,
+    HandleInput,
+    Output,
+    SecretStrInput,
+    StrInput,
+)
+
+
+class S3BucketUploaderComponent(Component):
+    """S3BucketUploaderComponent is a component responsible for uploading files to an S3 bucket.
+
+    It provides two strategies for file upload: "By Data" and "By File Name". The component
+    requires AWS credentials and bucket details as inputs and processes files accordingly.
+
+    Attributes:
+        display_name (str): The display name of the component.
+        description (str): A brief description of the components functionality.
+        icon (str): The icon representing the component.
+        name (str): The internal name of the component.
+        inputs (list): A list of input configurations required by the component.
+        outputs (list): A list of output configurations provided by the component.
+
+    Methods:
+        process_files() -> None:
+            Processes files based on the selected strategy. Calls the appropriate method
+            based on the strategy attribute.
+        process_files_by_data() -> None:
+            Processes and uploads files to an S3 bucket based on the data inputs. Iterates
+            over the data inputs, logs the file path and text content, and uploads each file
+            to the specified S3 bucket if both file path and text content are available.
+        process_files_by_name() -> None:
+            Processes and uploads files to an S3 bucket based on their names. Iterates through
+            the list of data inputs, retrieves the file path from each data item, and uploads
+            the file to the specified S3 bucket if the file path is available. Logs the file
+            path being uploaded.
+        _s3_client() -> Any:
+            Creates and returns an S3 client using the provided AWS access key ID and secret
+            access key.
+
+        Please note that this component requires the boto3 library to be installed. It is designed
+        to work with File and Director components as inputs
+    """
+
+    display_name = "S3 Bucket Uploader"
+    description = "Uploads files to S3 bucket."
+    icon = "Amazon"
+    name = "s3bucketuploader"
+
+    inputs = [
+        SecretStrInput(
+            name="aws_access_key_id",
+            display_name="AWS Access Key ID",
+            required=True,
+            password=True,
+            info="AWS Access key ID.",
+        ),
+        SecretStrInput(
+            name="aws_secret_access_key",
+            display_name="AWS Secret Key",
+            required=True,
+            password=True,
+            info="AWS Secret Key.",
+        ),
+        StrInput(
+            name="bucket_name",
+            display_name="Bucket Name",
+            info="Enter the name of the bucket.",
+            advanced=False,
+        ),
+        DropdownInput(
+            name="strategy",
+            display_name="Strategy for file upload",
+            options=["Store Data", "Store Original File"],
+            value="By Data",
+            info=(
+                "Choose the strategy to upload the file. By Data means that the source file "
+                "is parsed and stored as LangFlow data. By File Name means that the source "
+                "file is uploaded as is."
+            ),
+        ),
+        HandleInput(
+            name="data_inputs",
+            display_name="Data Inputs",
+            info="The data to split.",
+            input_types=["Data"],
+            is_list=True,
+            required=True,
+        ),
+        StrInput(
+            name="s3_prefix",
+            display_name="S3 Prefix",
+            info="Prefix for all files.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="strip_path",
+            display_name="Strip Path",
+            info="Removes path from file path.",
+            required=True,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Writes to AWS Bucket", name="data", method="process_files"),
+    ]
+
+    def process_files(self) -> None:
+        """Process files based on the selected strategy.
+
+        This method uses a strategy pattern to process files. The strategy is determined
+        by the `self.strategy` attribute, which can be either "By Data" or "By File Name".
+        Depending on the strategy, the corresponding method (`process_files_by_data` or
+        `process_files_by_name`) is called. If an invalid strategy is provided, an error
+        is logged.
+
+        Returns:
+            None
+        """
+        strategy_methods = {
+            "Store Data": self.process_files_by_data,
+            "Store Original File": self.process_files_by_name,
+        }
+        strategy_methods.get(self.strategy, lambda: self.log("Invalid strategy"))()
+
+    def process_files_by_data(self) -> None:
+        """Processes and uploads files to an S3 bucket based on the data inputs.
+
+        This method iterates over the data inputs, logs the file path and text content,
+        and uploads each file to the specified S3 bucket if both file path and text content
+        are available.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        for data_item in self.data_inputs:
+            file_path = data_item.data.get("file_path")
+            text_content = data_item.data.get("text")
+
+            if file_path and text_content:
+                self._s3_client().put_object(
+                    Bucket=self.bucket_name, Key=self._normalize_path(file_path), Body=text_content
+                )
+
+    def process_files_by_name(self) -> None:
+        """Processes and uploads files to an S3 bucket based on their names.
+
+        Iterates through the list of data inputs, retrieves the file path from each data item,
+        and uploads the file to the specified S3 bucket if the file path is available.
+        Logs the file path being uploaded.
+
+        Returns:
+            None
+        """
+        for data_item in self.data_inputs:
+            file_path = data_item.data.get("file_path")
+            self.log(f"Uploading file: {file_path}")
+            if file_path:
+                self._s3_client().upload_file(file_path, Bucket=self.bucket_name, Key=self._normalize_path(file_path))
+
+    def _s3_client(self) -> Any:
+        """Creates and returns an S3 client using the provided AWS access key ID and secret access key.
+
+        Returns:
+            Any: A boto3 S3 client instance.
+        """
+        try:
+            import boto3
+        except ImportError as e:
+            msg = "boto3 is not installed. Please install it using `uv pip install boto3`."
+            raise ImportError(msg) from e
+
+        return boto3.client(
+            "s3",
+            aws_access_key_id=self.aws_access_key_id,
+            aws_secret_access_key=self.aws_secret_access_key,
+        )
+
+    def _normalize_path(self, file_path) -> str:
+        """Process the file path based on the s3_prefix and path_as_prefix.
+
+        Args:
+            file_path (str): The original file path.
+            s3_prefix (str): The S3 prefix to use.
+            path_as_prefix (bool): Whether to use the file path as the S3 prefix.
+
+        Returns:
+            str: The processed file path.
+        """
+        prefix = self.s3_prefix
+        strip_path = self.strip_path
+        processed_path: str = file_path
+
+        if strip_path:
+            # Filename only
+            processed_path = Path(file_path).name
+
+        # Concatenate the s3_prefix if it exists
+        if prefix:
+            processed_path = str(Path(prefix) / processed_path)
+
+        return processed_path

lfx/components/anthropic/__init__.py

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

lfx/components/anthropic/anthropic.py

@@ -0,0 +1,187 @@
+from typing import Any, cast
+
+import requests
+from pydantic import ValidationError
+
+from lfx.base.models.anthropic_constants import (
+    ANTHROPIC_MODELS,
+    DEFAULT_ANTHROPIC_API_URL,
+    TOOL_CALLING_SUPPORTED_ANTHROPIC_MODELS,
+    TOOL_CALLING_UNSUPPORTED_ANTHROPIC_MODELS,
+)
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput, SliderInput
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
+
+
+class AnthropicModelComponent(LCModelComponent):
+    display_name = "Anthropic"
+    description = "Generate text using Anthropic's Messages API and models."
+    icon = "Anthropic"
+    name = "AnthropicModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            value=4096,
+            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            options=ANTHROPIC_MODELS,
+            refresh_button=True,
+            value=ANTHROPIC_MODELS[0],
+            combobox=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Anthropic API Key",
+            info="Your Anthropic API key.",
+            value=None,
+            required=True,
+            real_time_refresh=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            info="Run inference with this temperature. Must by in the closed interval [0.0, 1.0].",
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="base_url",
+            display_name="Anthropic API URL",
+            info="Endpoint of the Anthropic API. Defaults to 'https://api.anthropic.com' if not specified.",
+            value=DEFAULT_ANTHROPIC_API_URL,
+            real_time_refresh=True,
+            advanced=True,
+        ),
+        BoolInput(
+            name="tool_model_enabled",
+            display_name="Enable Tool Models",
+            info=(
+                "Select if you want to use models that can work with tools. If yes, only those models will be shown."
+            ),
+            advanced=False,
+            value=False,
+            real_time_refresh=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            from langchain_anthropic.chat_models import ChatAnthropic
+        except ImportError as e:
+            msg = "langchain_anthropic is not installed. Please install it with `pip install langchain_anthropic`."
+            raise ImportError(msg) from e
+        try:
+            max_tokens_value = getattr(self, "max_tokens", "")
+            max_tokens_value = 4096 if max_tokens_value == "" else int(max_tokens_value)
+            output = ChatAnthropic(
+                model=self.model_name,
+                anthropic_api_key=self.api_key,
+                max_tokens=max_tokens_value,
+                temperature=self.temperature,
+                anthropic_api_url=self.base_url or DEFAULT_ANTHROPIC_API_URL,
+                streaming=self.stream,
+            )
+        except ValidationError:
+            raise
+        except Exception as e:
+            msg = "Could not connect to Anthropic API."
+            raise ValueError(msg) from e
+
+        return output
+
+    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
+        try:
+            import anthropic
+
+            client = anthropic.Anthropic(api_key=self.api_key)
+            models = client.models.list(limit=20).data
+            model_ids = ANTHROPIC_MODELS + [model.id for model in models]
+        except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+            logger.exception(f"Error getting model names: {e}")
+            model_ids = ANTHROPIC_MODELS
+
+        if tool_model_enabled:
+            try:
+                from langchain_anthropic.chat_models import ChatAnthropic
+            except ImportError as e:
+                msg = "langchain_anthropic is not installed. Please install it with `pip install langchain_anthropic`."
+                raise ImportError(msg) from e
+
+            # Create a new list instead of modifying while iterating
+            filtered_models = []
+            for model in model_ids:
+                if model in TOOL_CALLING_SUPPORTED_ANTHROPIC_MODELS:
+                    filtered_models.append(model)
+                    continue
+
+                model_with_tool = ChatAnthropic(
+                    model=model,  # Use the current model being checked
+                    anthropic_api_key=self.api_key,
+                    anthropic_api_url=cast("str", self.base_url) or DEFAULT_ANTHROPIC_API_URL,
+                )
+
+                if (
+                    not self.supports_tool_calling(model_with_tool)
+                    or model in TOOL_CALLING_UNSUPPORTED_ANTHROPIC_MODELS
+                ):
+                    continue
+
+                filtered_models.append(model)
+
+            return filtered_models
+
+        return model_ids
+
+    def _get_exception_message(self, exception: Exception) -> str | None:
+        """Get a message from an Anthropic exception.
+
+        Args:
+            exception (Exception): The exception to get the message from.
+
+        Returns:
+            str: The message from the exception.
+        """
+        try:
+            from anthropic import BadRequestError
+        except ImportError:
+            return None
+        if isinstance(exception, BadRequestError):
+            message = exception.body.get("error", {}).get("message")
+            if message:
+                return message
+        return None
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        if "base_url" in build_config and build_config["base_url"]["value"] is None:
+            build_config["base_url"]["value"] = DEFAULT_ANTHROPIC_API_URL
+            self.base_url = DEFAULT_ANTHROPIC_API_URL
+        if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
+            try:
+                if len(self.api_key) == 0:
+                    ids = ANTHROPIC_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 = ANTHROPIC_MODELS
+                build_config.setdefault("model_name", {})
+                build_config["model_name"]["options"] = ids
+                build_config["model_name"].setdefault("value", ids[0])
+                build_config["model_name"]["combobox"] = True
+            except Exception as e:
+                msg = f"Error getting model names: {e}"
+                raise ValueError(msg) from e
+        return build_config

lfx/components/apify/__init__.py

@@ -0,0 +1,5 @@
+from .apify_actor import ApifyActorsComponent
+
+__all__ = [
+    "ApifyActorsComponent",
+]