lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/amazon/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.amazon.amazon_bedrock_embedding import AmazonBedrockEmbeddingsComponent
+    from lfx.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
+    from lfx.components.amazon.s3_bucket_uploader import S3BucketUploaderComponent
+
+_dynamic_imports = {
+    "AmazonBedrockEmbeddingsComponent": "amazon_bedrock_embedding",
+    "AmazonBedrockComponent": "amazon_bedrock_model",
+    "S3BucketUploaderComponent": "s3_bucket_uploader",
+}
+
+__all__ = ["AmazonBedrockComponent", "AmazonBedrockEmbeddingsComponent", "S3BucketUploaderComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import amazon 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/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,124 @@
+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."
+    icon = "Amazon"
+    name = "AmazonBedrockModel"
+
+    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__)