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

langflow/components/amazon/__init__.py

@@ -1,36 +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.amazon.amazon_bedrock_embedding import AmazonBedrockEmbeddingsComponent
-    from langflow.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
-    from langflow.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__)

langflow/components/amazon/amazon_bedrock_embedding.py

@@ -1,109 +0,0 @@
-from langflow.base.models.aws_constants import AWS_EMBEDDING_MODEL_IDS, AWS_REGIONS
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import Embeddings
-from langflow.inputs.inputs import SecretStrInput
-from langflow.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,
-        )

langflow/components/amazon/amazon_bedrock_model.py

@@ -1,124 +0,0 @@
-from langflow.base.models.aws_constants import AWS_REGIONS, AWS_MODEL_IDs
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.inputs.inputs import MessageTextInput, SecretStrInput
-from langflow.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._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

langflow/components/amazon/s3_bucket_uploader.py

@@ -1,211 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-from langflow.custom.custom_component.component import Component
-from langflow.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

langflow/components/anthropic/__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.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__)