lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/components/datastax/astra_db.py

@@ -1,77 +0,0 @@
-import os
-
-from lfx.base.memory.model import LCChatMemoryComponent
-from lfx.field_typing.constants import Memory
-from lfx.inputs.inputs import MessageTextInput, SecretStrInput, StrInput
-
-
-class AstraDBChatMemory(LCChatMemoryComponent):
-    display_name = "Astra DB Chat Memory"
-    description = "Retrieves and store chat messages from Astra DB."
-    name = "AstraDBChatMemory"
-    documentation: str = "https://docs.langflow.org/bundles-datastax#astra-db-chat-memory"
-    icon: str = "AstraDB"
-
-    inputs = [
-        SecretStrInput(
-            name="token",
-            display_name="Astra DB Application Token",
-            info="Authentication token for accessing Astra DB.",
-            value="ASTRA_DB_APPLICATION_TOKEN",
-            required=True,
-            advanced=os.getenv("ASTRA_ENHANCED", "false").lower() == "true",
-        ),
-        SecretStrInput(
-            name="api_endpoint",
-            display_name="Astra DB API Endpoint",
-            info="API endpoint URL for the Astra DB service.",
-            value="ASTRA_DB_API_ENDPOINT",
-            required=True,
-        ),
-        StrInput(
-            name="collection_name",
-            display_name="Collection Name",
-            info="The name of the collection within Astra DB where the vectors will be stored.",
-            required=True,
-        ),
-        StrInput(
-            name="namespace",
-            display_name="Namespace",
-            info="Optional namespace within Astra DB to use for the collection.",
-            advanced=True,
-        ),
-        MessageTextInput(
-            name="session_id",
-            display_name="Session ID",
-            info="The session ID of the chat. If empty, the current session ID parameter will be used.",
-            advanced=True,
-        ),
-    ]
-
-    def build_message_history(self) -> Memory:
-        try:
-            from astrapy.admin import parse_api_endpoint
-            from langchain_astradb.chat_message_histories import AstraDBChatMessageHistory
-
-        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.admin import parse_api_endpoint
-
-        except ImportError as e:
-            msg = "Could not import astrapy package. "
-            raise ImportError(msg) from e
-
-        return AstraDBChatMessageHistory(
-            session_id=self.session_id,
-            collection_name=self.collection_name,
-            token=self.token,
-            api_endpoint=self.api_endpoint,
-            namespace=self.namespace or None,
-            environment=parse_api_endpoint(self.api_endpoint).environment,
-        )

lfx/components/datastax/cassandra.py

@@ -1,92 +0,0 @@
-from lfx.base.memory.model import LCChatMemoryComponent
-from lfx.field_typing.constants import Memory
-from lfx.inputs.inputs import DictInput, MessageTextInput, SecretStrInput
-
-
-class CassandraChatMemory(LCChatMemoryComponent):
-    display_name = "Cassandra Chat Memory"
-    description = "Retrieves and store chat messages from Apache Cassandra."
-    name = "CassandraChatMemory"
-    icon = "Cassandra"
-
-    inputs = [
-        MessageTextInput(
-            name="database_ref",
-            display_name="Contact Points / Astra Database ID",
-            info="Contact points for the database (or Astra DB database ID)",
-            required=True,
-        ),
-        MessageTextInput(
-            name="username", display_name="Username", info="Username for the database (leave empty for Astra DB)."
-        ),
-        SecretStrInput(
-            name="token",
-            display_name="Password / Astra DB Token",
-            info="User password for the database (or Astra DB token).",
-            required=True,
-        ),
-        MessageTextInput(
-            name="keyspace",
-            display_name="Keyspace",
-            info="Table Keyspace (or Astra DB namespace).",
-            required=True,
-        ),
-        MessageTextInput(
-            name="table_name",
-            display_name="Table Name",
-            info="The name of the table (or Astra DB collection) where vectors will be stored.",
-            required=True,
-        ),
-        MessageTextInput(
-            name="session_id", display_name="Session ID", info="Session ID for the message.", advanced=True
-        ),
-        DictInput(
-            name="cluster_kwargs",
-            display_name="Cluster arguments",
-            info="Optional dictionary of additional keyword arguments for the Cassandra cluster.",
-            advanced=True,
-            is_list=True,
-        ),
-    ]
-
-    def build_message_history(self) -> Memory:
-        from langchain_community.chat_message_histories import CassandraChatMessageHistory
-
-        try:
-            import cassio
-        except ImportError as e:
-            msg = "Could not import cassio integration package. Please install it with `pip install cassio`."
-            raise ImportError(msg) from e
-
-        from uuid import UUID
-
-        database_ref = self.database_ref
-
-        try:
-            UUID(self.database_ref)
-            is_astra = True
-        except ValueError:
-            is_astra = False
-            if "," in self.database_ref:
-                # use a copy because we can't change the type of the parameter
-                database_ref = self.database_ref.split(",")
-
-        if is_astra:
-            cassio.init(
-                database_id=database_ref,
-                token=self.token,
-                cluster_kwargs=self.cluster_kwargs,
-            )
-        else:
-            cassio.init(
-                contact_points=database_ref,
-                username=self.username,
-                password=self.token,
-                cluster_kwargs=self.cluster_kwargs,
-            )
-
-        return CassandraChatMessageHistory(
-            session_id=self.session_id,
-            table_name=self.table_name,
-            keyspace=self.keyspace,
-        )

lfx/components/logic/run_flow.py

@@ -1,71 +0,0 @@
-from typing import Any
-
-from lfx.base.tools.run_flow import RunFlowBaseComponent
-from lfx.helpers import run_flow
-from lfx.log.logger import logger
-from lfx.schema.dotdict import dotdict
-
-
-class RunFlowComponent(RunFlowBaseComponent):
-    display_name = "Run Flow"
-    description = (
-        "Creates a tool component from a Flow that takes all its inputs and runs it. "
-        " \n **Select a Flow to use the tool mode**"
-    )
-    documentation: str = "https://docs.langflow.org/components-logic#run-flow"
-    beta = True
-    name = "RunFlow"
-    icon = "Workflow"
-
-    inputs = RunFlowBaseComponent.get_base_inputs()
-    outputs = RunFlowBaseComponent.get_base_outputs()
-
-    async def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name == "flow_name_selected":
-            build_config["flow_name_selected"]["options"] = await self.get_flow_names()
-            missing_keys = [key for key in self.default_keys if key not in build_config]
-            if missing_keys:
-                msg = f"Missing required keys in build_config: {missing_keys}"
-                raise ValueError(msg)
-            if field_value is not None:
-                try:
-                    graph = await self.get_graph(field_value)
-                    build_config = self.update_build_config_from_graph(build_config, graph)
-                except Exception as e:
-                    msg = f"Error building graph for flow {field_value}"
-                    await logger.aexception(msg)
-                    raise RuntimeError(msg) from e
-        return build_config
-
-    async def run_flow_with_tweaks(self):
-        tweaks: dict = {}
-
-        flow_name_selected = self._attributes.get("flow_name_selected")
-        parsed_flow_tweak_data = self._attributes.get("flow_tweak_data", {})
-        if not isinstance(parsed_flow_tweak_data, dict):
-            parsed_flow_tweak_data = parsed_flow_tweak_data.dict()
-
-        if parsed_flow_tweak_data != {}:
-            for field in parsed_flow_tweak_data:
-                if "~" in field:
-                    [node, name] = field.split("~")
-                    if node not in tweaks:
-                        tweaks[node] = {}
-                    tweaks[node][name] = parsed_flow_tweak_data[field]
-        else:
-            for field in self._attributes:
-                if field not in self.default_keys and "~" in field:
-                    [node, name] = field.split("~")
-                    if node not in tweaks:
-                        tweaks[node] = {}
-                    tweaks[node][name] = self._attributes[field]
-
-        return await run_flow(
-            inputs=None,
-            output_type="all",
-            flow_id=None,
-            flow_name=flow_name_selected,
-            tweaks=tweaks,
-            user_id=str(self.user_id),
-            session_id=self.graph.session_id or self.session_id,
-        )

lfx/components/models/embedding_model.py

@@ -1,114 +0,0 @@
-from typing import Any
-
-from langchain_openai import OpenAIEmbeddings
-
-from lfx.base.embeddings.model import LCEmbeddingsModel
-from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
-from lfx.field_typing import Embeddings
-from lfx.io import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    FloatInput,
-    IntInput,
-    MessageTextInput,
-    SecretStrInput,
-)
-from lfx.schema.dotdict import dotdict
-
-
-class EmbeddingModelComponent(LCEmbeddingsModel):
-    display_name = "Embedding Model"
-    description = "Generate embeddings using a specified provider."
-    documentation: str = "https://docs.langflow.org/components-embedding-models"
-    icon = "binary"
-    name = "EmbeddingModel"
-    category = "models"
-
-    inputs = [
-        DropdownInput(
-            name="provider",
-            display_name="Model Provider",
-            options=["OpenAI"],
-            value="OpenAI",
-            info="Select the embedding model provider",
-            real_time_refresh=True,
-            options_metadata=[{"icon": "OpenAI"}],
-        ),
-        DropdownInput(
-            name="model",
-            display_name="Model Name",
-            options=OPENAI_EMBEDDING_MODEL_NAMES,
-            value=OPENAI_EMBEDDING_MODEL_NAMES[0],
-            info="Select the embedding model to use",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="OpenAI API Key",
-            info="Model Provider API key",
-            required=True,
-            show=True,
-            real_time_refresh=True,
-        ),
-        MessageTextInput(
-            name="api_base",
-            display_name="API Base URL",
-            info="Base URL for the API. Leave empty for default.",
-            advanced=True,
-        ),
-        IntInput(
-            name="dimensions",
-            display_name="Dimensions",
-            info="The number of dimensions the resulting output embeddings should have. "
-            "Only supported by certain models.",
-            advanced=True,
-        ),
-        IntInput(name="chunk_size", display_name="Chunk Size", advanced=True, value=1000),
-        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
-        IntInput(name="max_retries", display_name="Max Retries", advanced=True, value=3),
-        BoolInput(name="show_progress_bar", display_name="Show Progress Bar", advanced=True),
-        DictInput(
-            name="model_kwargs",
-            display_name="Model Kwargs",
-            advanced=True,
-            info="Additional keyword arguments to pass to the model.",
-        ),
-    ]
-
-    def build_embeddings(self) -> Embeddings:
-        provider = self.provider
-        model = self.model
-        api_key = self.api_key
-        api_base = self.api_base
-        dimensions = self.dimensions
-        chunk_size = self.chunk_size
-        request_timeout = self.request_timeout
-        max_retries = self.max_retries
-        show_progress_bar = self.show_progress_bar
-        model_kwargs = self.model_kwargs or {}
-
-        if provider == "OpenAI":
-            if not api_key:
-                msg = "OpenAI API key is required when using OpenAI provider"
-                raise ValueError(msg)
-            return OpenAIEmbeddings(
-                model=model,
-                dimensions=dimensions or None,
-                base_url=api_base or None,
-                api_key=api_key,
-                chunk_size=chunk_size,
-                max_retries=max_retries,
-                timeout=request_timeout or None,
-                show_progress_bar=show_progress_bar,
-                model_kwargs=model_kwargs,
-            )
-        msg = f"Unknown provider: {provider}"
-        raise ValueError(msg)
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
-        if field_name == "provider" and field_value == "OpenAI":
-            build_config["model"]["options"] = OPENAI_EMBEDDING_MODEL_NAMES
-            build_config["model"]["value"] = OPENAI_EMBEDDING_MODEL_NAMES[0]
-            build_config["api_key"]["display_name"] = "OpenAI API Key"
-            build_config["api_base"]["display_name"] = "OpenAI API Base URL"
-        return build_config

lfx/components/models/language_model.py

@@ -1,144 +0,0 @@
-from typing import Any
-
-from langchain_anthropic import ChatAnthropic
-from langchain_openai import ChatOpenAI
-
-from lfx.base.models.anthropic_constants import ANTHROPIC_MODELS
-from lfx.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
-from lfx.base.models.google_generative_ai_model import ChatGoogleGenerativeAIFixed
-from lfx.base.models.model import LCModelComponent
-from lfx.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES, OPENAI_REASONING_MODEL_NAMES
-from lfx.field_typing import LanguageModel
-from lfx.field_typing.range_spec import RangeSpec
-from lfx.inputs.inputs import BoolInput
-from lfx.io import DropdownInput, MessageInput, MultilineInput, SecretStrInput, SliderInput
-from lfx.schema.dotdict import dotdict
-
-
-class LanguageModelComponent(LCModelComponent):
-    display_name = "Language Model"
-    description = "Runs a language model given a specified provider."
-    documentation: str = "https://docs.langflow.org/components-models"
-    icon = "brain-circuit"
-    category = "models"
-    priority = 0  # Set priority to 0 to make it appear first
-
-    inputs = [
-        DropdownInput(
-            name="provider",
-            display_name="Model Provider",
-            options=["OpenAI", "Anthropic", "Google"],
-            value="OpenAI",
-            info="Select the model provider",
-            real_time_refresh=True,
-            options_metadata=[{"icon": "OpenAI"}, {"icon": "Anthropic"}, {"icon": "GoogleGenerativeAI"}],
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            options=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
-            value=OPENAI_CHAT_MODEL_NAMES[0],
-            info="Select the model to use",
-            real_time_refresh=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="OpenAI API Key",
-            info="Model Provider API key",
-            required=False,
-            show=True,
-            real_time_refresh=True,
-        ),
-        MessageInput(
-            name="input_value",
-            display_name="Input",
-            info="The input text to send to the model",
-        ),
-        MultilineInput(
-            name="system_message",
-            display_name="System Message",
-            info="A system message that helps set the behavior of the assistant",
-            advanced=False,
-        ),
-        BoolInput(
-            name="stream",
-            display_name="Stream",
-            info="Whether to stream the response",
-            value=False,
-            advanced=True,
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            info="Controls randomness in responses",
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            advanced=True,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:
-        provider = self.provider
-        model_name = self.model_name
-        temperature = self.temperature
-        stream = self.stream
-
-        if provider == "OpenAI":
-            if not self.api_key:
-                msg = "OpenAI API key is required when using OpenAI provider"
-                raise ValueError(msg)
-
-            if model_name in OPENAI_REASONING_MODEL_NAMES:
-                # reasoning models do not support temperature (yet)
-                temperature = None
-
-            return ChatOpenAI(
-                model_name=model_name,
-                temperature=temperature,
-                streaming=stream,
-                openai_api_key=self.api_key,
-            )
-        if provider == "Anthropic":
-            if not self.api_key:
-                msg = "Anthropic API key is required when using Anthropic provider"
-                raise ValueError(msg)
-            return ChatAnthropic(
-                model=model_name,
-                temperature=temperature,
-                streaming=stream,
-                anthropic_api_key=self.api_key,
-            )
-        if provider == "Google":
-            if not self.api_key:
-                msg = "Google API key is required when using Google provider"
-                raise ValueError(msg)
-            return ChatGoogleGenerativeAIFixed(
-                model=model_name,
-                temperature=temperature,
-                streaming=stream,
-                google_api_key=self.api_key,
-            )
-        msg = f"Unknown provider: {provider}"
-        raise ValueError(msg)
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
-        if field_name == "provider":
-            if field_value == "OpenAI":
-                build_config["model_name"]["options"] = OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES
-                build_config["model_name"]["value"] = OPENAI_CHAT_MODEL_NAMES[0]
-                build_config["api_key"]["display_name"] = "OpenAI API Key"
-            elif field_value == "Anthropic":
-                build_config["model_name"]["options"] = ANTHROPIC_MODELS
-                build_config["model_name"]["value"] = ANTHROPIC_MODELS[0]
-                build_config["api_key"]["display_name"] = "Anthropic API Key"
-            elif field_value == "Google":
-                build_config["model_name"]["options"] = GOOGLE_GENERATIVE_AI_MODELS
-                build_config["model_name"]["value"] = GOOGLE_GENERATIVE_AI_MODELS[0]
-                build_config["api_key"]["display_name"] = "Google API Key"
-        elif field_name == "model_name" and field_value.startswith("o1") and self.provider == "OpenAI":
-            # Hide system_message for o1 models - currently unsupported
-            if "system_message" in build_config:
-                build_config["system_message"]["show"] = False
-        elif field_name == "model_name" and not field_value.startswith("o1") and "system_message" in build_config:
-            build_config["system_message"]["show"] = True
-        return build_config