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

langflow/components/datastax/create_assistant.py

@@ -1,58 +0,0 @@
-from langflow.base.astra_assistants.util import get_patched_openai_client
-from langflow.custom.custom_component.component_with_cache import ComponentWithCache
-from langflow.inputs.inputs import MultilineInput, StrInput
-from langflow.logging.logger import logger
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class AssistantsCreateAssistant(ComponentWithCache):
-    icon = "AstraDB"
-    display_name = "Create Assistant"
-    description = "Creates an Assistant and returns it's id"
-
-    inputs = [
-        StrInput(
-            name="assistant_name",
-            display_name="Assistant Name",
-            info="Name for the assistant being created",
-        ),
-        StrInput(
-            name="instructions",
-            display_name="Instructions",
-            info="Instructions for the assistant, think of these as the system prompt.",
-        ),
-        StrInput(
-            name="model",
-            display_name="Model name",
-            info=(
-                "Model for the assistant.\n\n"
-                "Environment variables for provider credentials can be set with the Dotenv Component.\n\n"
-                "Models are supported via LiteLLM, "
-                "see (https://docs.litellm.ai/docs/providers) for supported model names and env vars."
-            ),
-            # refresh_model=True
-        ),
-        MultilineInput(
-            name="env_set",
-            display_name="Environment Set",
-            info="Dummy input to allow chaining with Dotenv Component.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Assistant ID", name="assistant_id", method="process_inputs"),
-    ]
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.client = get_patched_openai_client(self._shared_component_cache)
-
-    def process_inputs(self) -> Message:
-        logger.info(f"env_set is {self.env_set}")
-        assistant = self.client.beta.assistants.create(
-            name=self.assistant_name,
-            instructions=self.instructions,
-            model=self.model,
-        )
-        return Message(text=assistant.id)

langflow/components/datastax/create_thread.py

@@ -1,32 +0,0 @@
-from langflow.base.astra_assistants.util import get_patched_openai_client
-from langflow.custom.custom_component.component_with_cache import ComponentWithCache
-from langflow.inputs.inputs import MultilineInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class AssistantsCreateThread(ComponentWithCache):
-    display_name = "Create Assistant Thread"
-    description = "Creates a thread and returns the thread id"
-    icon = "AstraDB"
-    inputs = [
-        MultilineInput(
-            name="env_set",
-            display_name="Environment Set",
-            info="Dummy input to allow chaining with Dotenv Component.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Thread ID", name="thread_id", method="process_inputs"),
-    ]
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.client = get_patched_openai_client(self._shared_component_cache)
-
-    def process_inputs(self) -> Message:
-        thread = self.client.beta.threads.create()
-        thread_id = thread.id
-
-        return Message(text=thread_id)

langflow/components/datastax/dotenv.py

@@ -1,35 +0,0 @@
-import io
-
-from dotenv import load_dotenv
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import MultilineSecretInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class Dotenv(Component):
-    display_name = "Dotenv"
-    description = "Load .env file into env vars"
-    icon = "AstraDB"
-    inputs = [
-        MultilineSecretInput(
-            name="dotenv_file_content",
-            display_name="Dotenv file content",
-            info="Paste the content of your .env file directly, since contents are sensitive, "
-            "using a Global variable set as 'password' is recommended",
-        )
-    ]
-
-    outputs = [
-        Output(display_name="env_set", name="env_set", method="process_inputs"),
-    ]
-
-    def process_inputs(self) -> Message:
-        fake_file = io.StringIO(self.dotenv_file_content)
-        result = load_dotenv(stream=fake_file, override=True)
-
-        message = Message(text="No variables found in .env")
-        if result:
-            message = Message(text="Loaded .env")
-        return message

langflow/components/datastax/get_assistant.py

@@ -1,37 +0,0 @@
-from langflow.base.astra_assistants.util import get_patched_openai_client
-from langflow.custom.custom_component.component_with_cache import ComponentWithCache
-from langflow.inputs.inputs import MultilineInput, StrInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class AssistantsGetAssistantName(ComponentWithCache):
-    display_name = "Get Assistant name"
-    description = "Assistant by id"
-    icon = "AstraDB"
-    inputs = [
-        StrInput(
-            name="assistant_id",
-            display_name="Assistant ID",
-            info="ID of the assistant",
-        ),
-        MultilineInput(
-            name="env_set",
-            display_name="Environment Set",
-            info="Dummy input to allow chaining with Dotenv Component.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Assistant Name", name="assistant_name", method="process_inputs"),
-    ]
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.client = get_patched_openai_client(self._shared_component_cache)
-
-    def process_inputs(self) -> Message:
-        assistant = self.client.beta.assistants.retrieve(
-            assistant_id=self.assistant_id,
-        )
-        return Message(text=assistant.name)

langflow/components/datastax/getenvvar.py

@@ -1,30 +0,0 @@
-import os
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import StrInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class GetEnvVar(Component):
-    display_name = "Get Environment Variable"
-    description = "Gets the value of an environment variable from the system."
-    icon = "AstraDB"
-
-    inputs = [
-        StrInput(
-            name="env_var_name",
-            display_name="Environment Variable Name",
-            info="Name of the environment variable to get",
-        )
-    ]
-
-    outputs = [
-        Output(display_name="Environment Variable Value", name="env_var_value", method="process_inputs"),
-    ]
-
-    def process_inputs(self) -> Message:
-        if self.env_var_name not in os.environ:
-            msg = f"Environment variable {self.env_var_name} not set"
-            raise ValueError(msg)
-        return Message(text=os.environ[self.env_var_name])

langflow/components/datastax/graph_rag.py

@@ -1,141 +0,0 @@
-import inspect
-from abc import ABC
-
-import graph_retriever.strategies as strategies_module
-from langchain_graph_retriever import GraphRetriever
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent
-from langflow.helpers.data import docs_to_data
-from langflow.inputs.inputs import DropdownInput, HandleInput, MultilineInput, NestedDictInput, StrInput
-from langflow.schema.data import Data
-
-
-def traversal_strategies() -> list[str]:
-    """Retrieves a list of class names from the strategies_module.
-
-    This function uses the `inspect` module to get all the class members
-    from the `strategies_module` and returns their names as a list of strings.
-
-    Returns:
-        list[str]: A list of strategy class names.
-    """
-    classes = inspect.getmembers(strategies_module, inspect.isclass)
-    return [name for name, cls in classes if ABC not in cls.__bases__]
-
-
-class GraphRAGComponent(LCVectorStoreComponent):
-    """GraphRAGComponent is a component for performing Graph RAG traversal in a vector store.
-
-    Attributes:
-        display_name (str): The display name of the component.
-        description (str): A brief description of the component.
-        name (str): The name of the component.
-        icon (str): The icon representing the component.
-        inputs (list): A list of input configurations for the component.
-
-    Methods:
-        _build_search_args():
-            Builds the arguments required for the search operation.
-        search_documents() -> list[Data]:
-            Searches for documents using the specified strategy, edge definition, and query.
-        _edge_definition_from_input() -> tuple:
-            Processes the edge definition input and returns it as a tuple.
-    """
-
-    display_name: str = "Graph RAG"
-    description: str = "Graph RAG traversal for vector store."
-    name = "Graph RAG"
-    icon: str = "AstraDB"
-
-    inputs = [
-        HandleInput(
-            name="embedding_model",
-            display_name="Embedding Model",
-            input_types=["Embeddings"],
-            info="Specify the Embedding Model. Not required for Astra Vectorize collections.",
-            required=False,
-        ),
-        HandleInput(
-            name="vector_store",
-            display_name="Vector Store Connection",
-            input_types=["VectorStore"],
-            info="Connection to Vector Store.",
-        ),
-        StrInput(
-            name="edge_definition",
-            display_name="Edge Definition",
-            info="Edge definition for the graph traversal.",
-        ),
-        DropdownInput(
-            name="strategy",
-            display_name="Traversal Strategies",
-            options=traversal_strategies(),
-        ),
-        MultilineInput(
-            name="search_query",
-            display_name="Search Query",
-            tool_mode=True,
-        ),
-        NestedDictInput(
-            name="graphrag_strategy_kwargs",
-            display_name="Strategy Parameters",
-            info=(
-                "Optional dictionary of additional parameters for the retrieval strategy. "
-                "Please see https://datastax.github.io/graph-rag/reference/graph_retriever/strategies/ for details."
-            ),
-            advanced=True,
-        ),
-    ]
-
-    def search_documents(self) -> list[Data]:
-        """Searches for documents using the graph retriever based on the selected strategy, edge definition, and query.
-
-        Returns:
-            list[Data]: A list of retrieved documents.
-
-        Raises:
-            AttributeError: If there is an issue with attribute access.
-            TypeError: If there is a type mismatch.
-            ValueError: If there is a value error.
-        """
-        additional_params = self.graphrag_strategy_kwargs or {}
-
-        # Invoke the graph retriever based on the selected strategy, edge definition, and query
-        strategy_class = getattr(strategies_module, self.strategy)
-        retriever = GraphRetriever(
-            store=self.vector_store,
-            edges=[self._evaluate_edge_definition_input()],
-            strategy=strategy_class(**additional_params),
-        )
-
-        return docs_to_data(retriever.invoke(self.search_query))
-
-    def _edge_definition_from_input(self) -> tuple:
-        """Generates the edge definition from the input data.
-
-        Returns:
-            tuple: A tuple representing the edge definition.
-        """
-        values = self.edge_definition.split(",")
-        values = [value.strip() for value in values]
-
-        return tuple(values)
-
-    def _evaluate_edge_definition_input(self) -> tuple:
-        from graph_retriever.edges.metadata import Id
-
-        """Evaluates the edge definition, converting any function calls from strings.
-
-        Args:
-            edge_definition (tuple): The edge definition to evaluate.
-
-        Returns:
-            tuple: The evaluated edge definition.
-        """
-        evaluated_values = []
-        for value in self._edge_definition_from_input():
-            if value == "Id()":
-                evaluated_values.append(Id())  # Evaluate Id() as a function call
-            else:
-                evaluated_values.append(value)
-        return tuple(evaluated_values)

langflow/components/datastax/hcd.py

@@ -1,314 +0,0 @@
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.inputs.inputs import DictInput, FloatInput
-from langflow.io import (
-    BoolInput,
-    DropdownInput,
-    HandleInput,
-    IntInput,
-    MultilineInput,
-    SecretStrInput,
-    StrInput,
-)
-from langflow.schema.data import Data
-
-
-class HCDVectorStoreComponent(LCVectorStoreComponent):
-    display_name: str = "Hyper-Converged Database"
-    description: str = "Implementation of Vector Store using Hyper-Converged Database (HCD) with search capabilities"
-    name = "HCD"
-    icon: str = "HCD"
-
-    inputs = [
-        StrInput(
-            name="collection_name",
-            display_name="Collection Name",
-            info="The name of the collection within HCD where the vectors will be stored.",
-            required=True,
-        ),
-        StrInput(
-            name="username",
-            display_name="HCD Username",
-            info="Authentication username for accessing HCD.",
-            value="hcd-superuser",
-            required=True,
-        ),
-        SecretStrInput(
-            name="password",
-            display_name="HCD Password",
-            info="Authentication password for accessing HCD.",
-            value="HCD_PASSWORD",
-            required=True,
-        ),
-        SecretStrInput(
-            name="api_endpoint",
-            display_name="HCD API Endpoint",
-            info="API endpoint URL for the HCD service.",
-            value="HCD_API_ENDPOINT",
-            required=True,
-        ),
-        *LCVectorStoreComponent.inputs,
-        StrInput(
-            name="namespace",
-            display_name="Namespace",
-            info="Optional namespace within HCD to use for the collection.",
-            value="default_namespace",
-            advanced=True,
-        ),
-        MultilineInput(
-            name="ca_certificate",
-            display_name="CA Certificate",
-            info="Optional CA certificate for TLS connections to HCD.",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="metric",
-            display_name="Metric",
-            info="Optional distance metric for vector comparisons in the vector store.",
-            options=["cosine", "dot_product", "euclidean"],
-            advanced=True,
-        ),
-        IntInput(
-            name="batch_size",
-            display_name="Batch Size",
-            info="Optional number of data to process in a single batch.",
-            advanced=True,
-        ),
-        IntInput(
-            name="bulk_insert_batch_concurrency",
-            display_name="Bulk Insert Batch Concurrency",
-            info="Optional concurrency level for bulk insert operations.",
-            advanced=True,
-        ),
-        IntInput(
-            name="bulk_insert_overwrite_concurrency",
-            display_name="Bulk Insert Overwrite Concurrency",
-            info="Optional concurrency level for bulk insert operations that overwrite existing data.",
-            advanced=True,
-        ),
-        IntInput(
-            name="bulk_delete_concurrency",
-            display_name="Bulk Delete Concurrency",
-            info="Optional concurrency level for bulk delete operations.",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="setup_mode",
-            display_name="Setup Mode",
-            info="Configuration mode for setting up the vector store, with options like 'Sync', 'Async', or 'Off'.",
-            options=["Sync", "Async", "Off"],
-            advanced=True,
-            value="Sync",
-        ),
-        BoolInput(
-            name="pre_delete_collection",
-            display_name="Pre Delete Collection",
-            info="Boolean flag to determine whether to delete the collection before creating a new one.",
-            advanced=True,
-        ),
-        StrInput(
-            name="metadata_indexing_include",
-            display_name="Metadata Indexing Include",
-            info="Optional list of metadata fields to include in the indexing.",
-            advanced=True,
-        ),
-        HandleInput(
-            name="embedding",
-            display_name="Embedding or Astra Vectorize",
-            input_types=["Embeddings", "dict"],
-            # TODO: This should be optional, but need to refactor langchain-astradb first.
-            info="Allows either an embedding model or an Astra Vectorize configuration.",
-        ),
-        StrInput(
-            name="metadata_indexing_exclude",
-            display_name="Metadata Indexing Exclude",
-            info="Optional list of metadata fields to exclude from the indexing.",
-            advanced=True,
-        ),
-        StrInput(
-            name="collection_indexing_policy",
-            display_name="Collection Indexing Policy",
-            info="Optional dictionary defining the indexing policy for the collection.",
-            advanced=True,
-        ),
-        IntInput(
-            name="number_of_results",
-            display_name="Number of Results",
-            info="Number of results to return.",
-            advanced=True,
-            value=4,
-        ),
-        DropdownInput(
-            name="search_type",
-            display_name="Search Type",
-            info="Search type to use",
-            options=["Similarity", "Similarity with score threshold", "MMR (Max Marginal Relevance)"],
-            value="Similarity",
-            advanced=True,
-        ),
-        FloatInput(
-            name="search_score_threshold",
-            display_name="Search Score Threshold",
-            info="Minimum similarity score threshold for search results. "
-            "(when using 'Similarity with score threshold')",
-            value=0,
-            advanced=True,
-        ),
-        DictInput(
-            name="search_filter",
-            display_name="Search Metadata Filter",
-            info="Optional dictionary of filters to apply to the search query.",
-            advanced=True,
-            is_list=True,
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self):
-        try:
-            from langchain_astradb import AstraDBVectorStore
-            from langchain_astradb.utils.astradb import SetupMode
-        except ImportError as e:
-            msg = (
-                "Could not import langchain Astra DB integration package. "
-                "Please install it with `pip install langchain-astradb`."
-            )
-            raise ImportError(msg) from e
-
-        try:
-            from astrapy.authentication import UsernamePasswordTokenProvider
-            from astrapy.constants import Environment
-        except ImportError as e:
-            msg = "Could not import astrapy integration package. Please install it with `pip install astrapy`."
-            raise ImportError(msg) from e
-
-        try:
-            if not self.setup_mode:
-                self.setup_mode = self._inputs["setup_mode"].options[0]
-
-            setup_mode_value = SetupMode[self.setup_mode.upper()]
-        except KeyError as e:
-            msg = f"Invalid setup mode: {self.setup_mode}"
-            raise ValueError(msg) from e
-
-        if not isinstance(self.embedding, dict):
-            embedding_dict = {"embedding": self.embedding}
-        else:
-            from astrapy.info import VectorServiceOptions
-
-            dict_options = self.embedding.get("collection_vector_service_options", {})
-            dict_options["authentication"] = {
-                k: v for k, v in dict_options.get("authentication", {}).items() if k and v
-            }
-            dict_options["parameters"] = {k: v for k, v in dict_options.get("parameters", {}).items() if k and v}
-            embedding_dict = {"collection_vector_service_options": VectorServiceOptions.from_dict(dict_options)}
-            collection_embedding_api_key = self.embedding.get("collection_embedding_api_key")
-            if collection_embedding_api_key:
-                embedding_dict["collection_embedding_api_key"] = collection_embedding_api_key
-
-        token_provider = UsernamePasswordTokenProvider(self.username, self.password)
-        vector_store_kwargs = {
-            **embedding_dict,
-            "collection_name": self.collection_name,
-            "token": token_provider,
-            "api_endpoint": self.api_endpoint,
-            "namespace": self.namespace,
-            "metric": self.metric or None,
-            "batch_size": self.batch_size or None,
-            "bulk_insert_batch_concurrency": self.bulk_insert_batch_concurrency or None,
-            "bulk_insert_overwrite_concurrency": self.bulk_insert_overwrite_concurrency or None,
-            "bulk_delete_concurrency": self.bulk_delete_concurrency or None,
-            "setup_mode": setup_mode_value,
-            "pre_delete_collection": self.pre_delete_collection or False,
-            "environment": Environment.HCD,
-        }
-
-        if self.metadata_indexing_include:
-            vector_store_kwargs["metadata_indexing_include"] = self.metadata_indexing_include
-        elif self.metadata_indexing_exclude:
-            vector_store_kwargs["metadata_indexing_exclude"] = self.metadata_indexing_exclude
-        elif self.collection_indexing_policy:
-            vector_store_kwargs["collection_indexing_policy"] = self.collection_indexing_policy
-
-        try:
-            vector_store = AstraDBVectorStore(**vector_store_kwargs)
-        except Exception as e:
-            msg = f"Error initializing AstraDBVectorStore: {e}"
-            raise ValueError(msg) from e
-
-        self._add_documents_to_vector_store(vector_store)
-        return vector_store
-
-    def _add_documents_to_vector_store(self, vector_store) -> None:
-        # Convert DataFrame to Data if needed using parent's method
-        self.ingest_data = self._prepare_ingest_data()
-
-        documents = []
-        for _input in self.ingest_data or []:
-            if isinstance(_input, Data):
-                documents.append(_input.to_lc_document())
-            else:
-                msg = "Vector Store Inputs must be Data objects."
-                raise TypeError(msg)
-
-        if documents:
-            self.log(f"Adding {len(documents)} documents to the Vector Store.")
-            try:
-                vector_store.add_documents(documents)
-            except Exception as e:
-                msg = f"Error adding documents to AstraDBVectorStore: {e}"
-                raise ValueError(msg) from e
-        else:
-            self.log("No documents to add to the Vector Store.")
-
-    def _map_search_type(self) -> str:
-        if self.search_type == "Similarity with score threshold":
-            return "similarity_score_threshold"
-        if self.search_type == "MMR (Max Marginal Relevance)":
-            return "mmr"
-        return "similarity"
-
-    def _build_search_args(self):
-        args = {
-            "k": self.number_of_results,
-            "score_threshold": self.search_score_threshold,
-        }
-
-        if self.search_filter:
-            clean_filter = {k: v for k, v in self.search_filter.items() if k and v}
-            if len(clean_filter) > 0:
-                args["filter"] = clean_filter
-        return args
-
-    def search_documents(self) -> list[Data]:
-        vector_store = self.build_vector_store()
-
-        self.log(f"Search query: {self.search_query}")
-        self.log(f"Search type: {self.search_type}")
-        self.log(f"Number of results: {self.number_of_results}")
-
-        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
-            try:
-                search_type = self._map_search_type()
-                search_args = self._build_search_args()
-
-                docs = vector_store.search(query=self.search_query, search_type=search_type, **search_args)
-            except Exception as e:
-                msg = f"Error performing search in AstraDBVectorStore: {e}"
-                raise ValueError(msg) from e
-
-            self.log(f"Retrieved documents: {len(docs)}")
-
-            data = docs_to_data(docs)
-            self.log(f"Converted documents to data: {len(data)}")
-            self.status = data
-            return data
-        self.log("No search input provided. Skipping search.")
-        return []
-
-    def get_retriever_kwargs(self):
-        search_args = self._build_search_args()
-        return {
-            "search_type": self._map_search_type(),
-            "search_kwargs": search_args,
-        }

langflow/components/datastax/list_assistants.py

@@ -1,25 +0,0 @@
-from langflow.base.astra_assistants.util import get_patched_openai_client
-from langflow.custom.custom_component.component_with_cache import ComponentWithCache
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class AssistantsListAssistants(ComponentWithCache):
-    display_name = "List Assistants"
-    description = "Returns a list of assistant id's"
-    icon = "AstraDB"
-    outputs = [
-        Output(display_name="Assistants", name="assistants", method="process_inputs"),
-    ]
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.client = get_patched_openai_client(self._shared_component_cache)
-
-    def process_inputs(self) -> Message:
-        assistants = self.client.beta.assistants.list().data
-        id_list = [assistant.id for assistant in assistants]
-        return Message(
-            # get text from list
-            text="\n".join(id_list)
-        )