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

lfx/components/embeddings/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.embeddings.similarity import EmbeddingSimilarityComponent
+    from lfx.components.embeddings.text_embedder import TextEmbedderComponent
+
+_dynamic_imports = {
+    "EmbeddingSimilarityComponent": "similarity",
+    "TextEmbedderComponent": "text_embedder",
+}
+
+__all__ = [
+    "EmbeddingSimilarityComponent",
+    "TextEmbedderComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import embedding 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/embeddings/similarity.py

@@ -0,0 +1,77 @@
+from typing import Any
+
+import numpy as np
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DataInput, DropdownInput, Output
+from lfx.schema.data import Data
+
+
+class EmbeddingSimilarityComponent(Component):
+    display_name: str = "Embedding Similarity"
+    description: str = "Compute selected form of similarity between two embedding vectors."
+    icon = "equal"
+    legacy: bool = True
+    replacement = ["datastax.AstraDB"]
+
+    inputs = [
+        DataInput(
+            name="embedding_vectors",
+            display_name="Embedding Vectors",
+            info="A list containing exactly two data objects with embedding vectors to compare.",
+            is_list=True,
+            required=True,
+        ),
+        DropdownInput(
+            name="similarity_metric",
+            display_name="Similarity Metric",
+            info="Select the similarity metric to use.",
+            options=["Cosine Similarity", "Euclidean Distance", "Manhattan Distance"],
+            value="Cosine Similarity",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Similarity Data", name="similarity_data", method="compute_similarity"),
+    ]
+
+    def compute_similarity(self) -> Data:
+        embedding_vectors: list[Data] = self.embedding_vectors
+
+        # Assert that the list contains exactly two Data objects
+        if len(embedding_vectors) != 2:  # noqa: PLR2004
+            msg = "Exactly two embedding vectors are required."
+            raise ValueError(msg)
+
+        embedding_1 = np.array(embedding_vectors[0].data["embeddings"])
+        embedding_2 = np.array(embedding_vectors[1].data["embeddings"])
+
+        if embedding_1.shape != embedding_2.shape:
+            similarity_score: dict[str, Any] = {"error": "Embeddings must have the same dimensions."}
+        else:
+            similarity_metric = self.similarity_metric
+
+            if similarity_metric == "Cosine Similarity":
+                score = np.dot(embedding_1, embedding_2) / (np.linalg.norm(embedding_1) * np.linalg.norm(embedding_2))
+                similarity_score = {"cosine_similarity": score}
+
+            elif similarity_metric == "Euclidean Distance":
+                score = np.linalg.norm(embedding_1 - embedding_2)
+                similarity_score = {"euclidean_distance": score}
+
+            elif similarity_metric == "Manhattan Distance":
+                score = np.sum(np.abs(embedding_1 - embedding_2))
+                similarity_score = {"manhattan_distance": score}
+
+        # Create a Data object to encapsulate the similarity score and additional information
+        similarity_data = Data(
+            data={
+                "embedding_1": embedding_vectors[0].data["embeddings"],
+                "embedding_2": embedding_vectors[1].data["embeddings"],
+                "similarity_score": similarity_score,
+            },
+            text_key="similarity_score",
+        )
+
+        self.status = similarity_data
+        return similarity_data

lfx/components/embeddings/text_embedder.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import HandleInput, MessageInput, Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+if TYPE_CHECKING:
+    from lfx.field_typing import Embeddings
+    from lfx.schema.message import Message
+
+
+class TextEmbedderComponent(Component):
+    display_name: str = "Text Embedder"
+    description: str = "Generate embeddings for a given message using the specified embedding model."
+    icon = "binary"
+    legacy: bool = True
+    replacement = ["models.EmbeddingModel"]
+    inputs = [
+        HandleInput(
+            name="embedding_model",
+            display_name="Embedding Model",
+            info="The embedding model to use for generating embeddings.",
+            input_types=["Embeddings"],
+            required=True,
+        ),
+        MessageInput(
+            name="message",
+            display_name="Message",
+            info="The message to generate embeddings for.",
+            required=True,
+        ),
+    ]
+    outputs = [
+        Output(display_name="Embedding Data", name="embeddings", method="generate_embeddings"),
+    ]
+
+    def generate_embeddings(self) -> Data:
+        try:
+            embedding_model: Embeddings = self.embedding_model
+            message: Message = self.message
+
+            # Combine validation checks to reduce nesting
+            if not embedding_model or not hasattr(embedding_model, "embed_documents"):
+                msg = "Invalid or incompatible embedding model"
+                raise ValueError(msg)
+
+            text_content = message.text if message and message.text else ""
+            if not text_content:
+                msg = "No text content found in message"
+                raise ValueError(msg)
+
+            embeddings = embedding_model.embed_documents([text_content])
+            if not embeddings or not isinstance(embeddings, list):
+                msg = "Invalid embeddings generated"
+                raise ValueError(msg)
+
+            embedding_vector = embeddings[0]
+            self.status = {"text": text_content, "embeddings": embedding_vector}
+            return Data(data={"text": text_content, "embeddings": embedding_vector})
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Error generating embeddings")
+            error_data = Data(data={"text": "", "embeddings": [], "error": str(e)})
+            self.status = {"error": str(e)}
+            return error_data

lfx/components/exa/__init__.py

@@ -0,0 +1,3 @@
+from .exa_search import ExaSearchToolkit
+
+__all__ = ["ExaSearchToolkit"]

lfx/components/exa/exa_search.py

@@ -0,0 +1,68 @@
+from langchain_core.tools import tool
+from metaphor_python import Metaphor
+
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing import Tool
+from lfx.io import BoolInput, IntInput, Output, SecretStrInput
+
+
+class ExaSearchToolkit(Component):
+    display_name = "Exa Search"
+    description = "Exa Search toolkit for search and content retrieval"
+    documentation = "https://python.langchain.com/docs/integrations/tools/metaphor_search"
+    beta = True
+    name = "ExaSearch"
+    icon = "ExaSearch"
+
+    inputs = [
+        SecretStrInput(
+            name="metaphor_api_key",
+            display_name="Exa Search API Key",
+            password=True,
+        ),
+        BoolInput(
+            name="use_autoprompt",
+            display_name="Use Autoprompt",
+            value=True,
+        ),
+        IntInput(
+            name="search_num_results",
+            display_name="Search Number of Results",
+            value=5,
+        ),
+        IntInput(
+            name="similar_num_results",
+            display_name="Similar Number of Results",
+            value=5,
+        ),
+    ]
+
+    outputs = [
+        Output(name="tools", display_name="Tools", method="build_toolkit"),
+    ]
+
+    def build_toolkit(self) -> Tool:
+        client = Metaphor(api_key=self.metaphor_api_key)
+
+        @tool
+        def search(query: str):
+            """Call search engine with a query."""
+            return client.search(query, use_autoprompt=self.use_autoprompt, num_results=self.search_num_results)
+
+        @tool
+        def get_contents(ids: list[str]):
+            """Get contents of a webpage.
+
+            The ids passed in should be a list of ids as fetched from `search`.
+            """
+            return client.get_contents(ids)
+
+        @tool
+        def find_similar(url: str):
+            """Get search results similar to a given URL.
+
+            The url passed in should be a URL returned from `search`
+            """
+            return client.find_similar(url, num_results=self.similar_num_results)
+
+        return [search, get_contents, find_similar]

lfx/components/files_and_knowledge/__init__.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.files_and_knowledge.directory import DirectoryComponent
+    from lfx.components.files_and_knowledge.file import FileComponent
+    from lfx.components.files_and_knowledge.ingestion import KnowledgeIngestionComponent
+    from lfx.components.files_and_knowledge.retrieval import KnowledgeRetrievalComponent
+    from lfx.components.files_and_knowledge.save_file import SaveToFileComponent
+
+
+_dynamic_imports = {
+    "DirectoryComponent": "directory",
+    "FileComponent": "file",
+    "KnowledgeIngestionComponent": "ingestion",
+    "KnowledgeRetrievalComponent": "retrieval",
+    "SaveToFileComponent": "save_file",
+}
+
+__all__ = [
+    "DirectoryComponent",
+    "FileComponent",
+    "KnowledgeIngestionComponent",
+    "KnowledgeRetrievalComponent",
+    "SaveToFileComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import files and knowledge 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/files_and_knowledge/directory.py

@@ -0,0 +1,113 @@
+from lfx.base.data.utils import TEXT_FILE_TYPES, parallel_load_data, parse_text_file_to_data, retrieve_file_paths
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, IntInput, MessageTextInput, MultiselectInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+
+class DirectoryComponent(Component):
+    display_name = "Directory"
+    description = "Recursively load files from a directory."
+    documentation: str = "https://docs.langflow.org/directory"
+    icon = "folder"
+    name = "Directory"
+
+    inputs = [
+        MessageTextInput(
+            name="path",
+            display_name="Path",
+            info="Path to the directory to load files from. Defaults to current directory ('.')",
+            value=".",
+            tool_mode=True,
+        ),
+        MultiselectInput(
+            name="types",
+            display_name="File Types",
+            info="File types to load. Select one or more types or leave empty to load all supported types.",
+            options=TEXT_FILE_TYPES,
+            value=[],
+        ),
+        IntInput(
+            name="depth",
+            display_name="Depth",
+            info="Depth to search for files.",
+            value=0,
+        ),
+        IntInput(
+            name="max_concurrency",
+            display_name="Max Concurrency",
+            advanced=True,
+            info="Maximum concurrency for loading files.",
+            value=2,
+        ),
+        BoolInput(
+            name="load_hidden",
+            display_name="Load Hidden",
+            advanced=True,
+            info="If true, hidden files will be loaded.",
+        ),
+        BoolInput(
+            name="recursive",
+            display_name="Recursive",
+            advanced=True,
+            info="If true, the search will be recursive.",
+        ),
+        BoolInput(
+            name="silent_errors",
+            display_name="Silent Errors",
+            advanced=True,
+            info="If true, errors will not raise an exception.",
+        ),
+        BoolInput(
+            name="use_multithreading",
+            display_name="Use Multithreading",
+            advanced=True,
+            info="If true, multithreading will be used.",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Loaded Files", name="dataframe", method="as_dataframe"),
+    ]
+
+    def load_directory(self) -> list[Data]:
+        path = self.path
+        types = self.types
+        depth = self.depth
+        max_concurrency = self.max_concurrency
+        load_hidden = self.load_hidden
+        recursive = self.recursive
+        silent_errors = self.silent_errors
+        use_multithreading = self.use_multithreading
+
+        resolved_path = self.resolve_path(path)
+
+        # If no types are specified, use all supported types
+        if not types:
+            types = TEXT_FILE_TYPES
+
+        # Check if all specified types are valid
+        invalid_types = [t for t in types if t not in TEXT_FILE_TYPES]
+        if invalid_types:
+            msg = f"Invalid file types specified: {invalid_types}. Valid types are: {TEXT_FILE_TYPES}"
+            raise ValueError(msg)
+
+        valid_types = types
+
+        file_paths = retrieve_file_paths(
+            resolved_path, load_hidden=load_hidden, recursive=recursive, depth=depth, types=valid_types
+        )
+
+        loaded_data = []
+        if use_multithreading:
+            loaded_data = parallel_load_data(file_paths, silent_errors=silent_errors, max_concurrency=max_concurrency)
+        else:
+            loaded_data = [parse_text_file_to_data(file_path, silent_errors=silent_errors) for file_path in file_paths]
+
+        valid_data = [x for x in loaded_data if x is not None and isinstance(x, Data)]
+        self.status = valid_data
+        return valid_data
+
+    def as_dataframe(self) -> DataFrame:
+        return DataFrame(self.load_directory())