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

langflow/schema/openai_responses_schemas.py

@@ -1,74 +0,0 @@
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field
-
-
-class OpenAIResponsesRequest(BaseModel):
-    """OpenAI-compatible responses request with flow_id as model parameter."""
-
-    model: str = Field(..., description="The flow ID to execute (used instead of OpenAI model)")
-    input: str = Field(..., description="The input text to process")
-    stream: bool = Field(default=False, description="Whether to stream the response")
-    background: bool = Field(default=False, description="Whether to process in background")
-    tools: list[Any] | None = Field(default=None, description="Tools are not supported yet")
-    previous_response_id: str | None = Field(
-        default=None, description="ID of previous response to continue conversation"
-    )
-    include: list[str] | None = Field(
-        default=None, description="Additional response data to include, e.g., ['tool_call.results']"
-    )
-
-
-class OpenAIResponsesResponse(BaseModel):
-    """OpenAI-compatible responses response."""
-
-    id: str
-    object: Literal["response"] = "response"
-    created_at: int
-    status: Literal["completed", "in_progress", "failed"] = "completed"
-    error: dict | None = None
-    incomplete_details: dict | None = None
-    instructions: str | None = None
-    max_output_tokens: int | None = None
-    model: str
-    output: list[dict]
-    parallel_tool_calls: bool = True
-    previous_response_id: str | None = None
-    reasoning: dict = Field(default_factory=lambda: {"effort": None, "summary": None})
-    store: bool = True
-    temperature: float = 1.0
-    text: dict = Field(default_factory=lambda: {"format": {"type": "text"}})
-    tool_choice: str = "auto"
-    tools: list[dict] = Field(default_factory=list)
-    top_p: float = 1.0
-    truncation: str = "disabled"
-    usage: dict | None = None
-    user: str | None = None
-    metadata: dict = Field(default_factory=dict)
-
-
-class OpenAIResponsesStreamChunk(BaseModel):
-    """OpenAI-compatible responses stream chunk."""
-
-    id: str
-    object: Literal["response.chunk"] = "response.chunk"
-    created: int
-    model: str
-    delta: dict
-    status: Literal["completed", "in_progress", "failed"] | None = None
-
-
-class OpenAIErrorResponse(BaseModel):
-    error: dict = Field(..., description="Error details")
-
-
-def create_openai_error(message: str, type_: str = "invalid_request_error", code: str | None = None) -> dict:
-    """Create an OpenAI-compatible error response."""
-    error_data = {
-        "message": message,
-        "type": type_,
-    }
-    if code:
-        error_data["code"] = code
-
-    return {"error": error_data}

langflow/schema/serialize.py

@@ -1,13 +0,0 @@
-from typing import Annotated
-from uuid import UUID
-
-from pydantic import BeforeValidator
-
-
-def str_to_uuid(v: str | UUID) -> UUID:
-    if isinstance(v, str):
-        return UUID(v)
-    return v
-
-
-UUIDstr = Annotated[UUID, BeforeValidator(str_to_uuid)]

langflow/services/chat/config.py

@@ -1,2 +0,0 @@
-class ChatConfig:
-    streaming: bool = True

langflow/services/settings/auth.py

@@ -1,130 +0,0 @@
-import secrets
-from pathlib import Path
-from typing import Literal
-
-from passlib.context import CryptContext
-from pydantic import Field, SecretStr, field_validator
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-from langflow.logging.logger import logger
-from langflow.services.settings.constants import DEFAULT_SUPERUSER, DEFAULT_SUPERUSER_PASSWORD
-from langflow.services.settings.utils import read_secret_from_file, write_secret_to_file
-
-
-class AuthSettings(BaseSettings):
-    # Login settings
-    CONFIG_DIR: str
-    SECRET_KEY: SecretStr = Field(
-        default=SecretStr(""),
-        description="Secret key for JWT. If not provided, a random one will be generated.",
-        frozen=False,
-    )
-    ALGORITHM: str = "HS256"
-    ACCESS_TOKEN_EXPIRE_SECONDS: int = 60 * 60  # 1 hour
-    REFRESH_TOKEN_EXPIRE_SECONDS: int = 60 * 60 * 24 * 7  # 7 days
-
-    # API Key to execute /process endpoint
-    API_KEY_ALGORITHM: str = "HS256"
-    API_V1_STR: str = "/api/v1"
-
-    AUTO_LOGIN: bool = Field(
-        default=True,  # TODO: Set to False in v1.6
-        description=(
-            "Enable automatic login with default credentials. "
-            "SECURITY WARNING: This bypasses authentication and should only be used in development environments. "
-            "Set to False in production."
-        ),
-    )
-    """If True, the application will attempt to log in automatically as a super user."""
-    skip_auth_auto_login: bool = True
-    """If True, the application will skip authentication when AUTO_LOGIN is enabled.
-    This will be removed in v1.6"""
-
-    WEBHOOK_AUTH_ENABLE: bool = False
-    """If True, webhook endpoints will require API key authentication.
-    If False, webhooks run as flow owner without authentication."""
-
-    ENABLE_SUPERUSER_CLI: bool = Field(
-        default=True,
-        description="Allow creation of superusers via CLI. Set to False in production for security.",
-    )
-    """If True, allows creation of superusers via the CLI 'langflow superuser' command."""
-
-    NEW_USER_IS_ACTIVE: bool = False
-    SUPERUSER: str = DEFAULT_SUPERUSER
-    SUPERUSER_PASSWORD: str = DEFAULT_SUPERUSER_PASSWORD
-
-    REFRESH_SAME_SITE: Literal["lax", "strict", "none"] = "none"
-    """The SameSite attribute of the refresh token cookie."""
-    REFRESH_SECURE: bool = True
-    """The Secure attribute of the refresh token cookie."""
-    REFRESH_HTTPONLY: bool = True
-    """The HttpOnly attribute of the refresh token cookie."""
-    ACCESS_SAME_SITE: Literal["lax", "strict", "none"] = "lax"
-    """The SameSite attribute of the access token cookie."""
-    ACCESS_SECURE: bool = False
-    """The Secure attribute of the access token cookie."""
-    ACCESS_HTTPONLY: bool = False
-    """The HttpOnly attribute of the access token cookie."""
-
-    COOKIE_DOMAIN: str | None = None
-    """The domain attribute of the cookies. If None, the domain is not set."""
-
-    pwd_context: CryptContext = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-    model_config = SettingsConfigDict(validate_assignment=True, extra="ignore", env_prefix="LANGFLOW_")
-
-    def reset_credentials(self) -> None:
-        self.SUPERUSER = DEFAULT_SUPERUSER
-        self.SUPERUSER_PASSWORD = DEFAULT_SUPERUSER_PASSWORD
-
-    # If autologin is true, then we need to set the credentials to
-    # the default values
-    # so we need to validate the superuser and superuser_password
-    # fields
-    @field_validator("SUPERUSER", "SUPERUSER_PASSWORD", mode="before")
-    @classmethod
-    def validate_superuser(cls, value, info):
-        if info.data.get("AUTO_LOGIN"):
-            if value != DEFAULT_SUPERUSER:
-                value = DEFAULT_SUPERUSER
-                logger.debug("Resetting superuser to default value")
-            if info.data.get("SUPERUSER_PASSWORD") != DEFAULT_SUPERUSER_PASSWORD:
-                info.data["SUPERUSER_PASSWORD"] = DEFAULT_SUPERUSER_PASSWORD
-                logger.debug("Resetting superuser password to default value")
-
-            return value
-
-        return value
-
-    @field_validator("SECRET_KEY", mode="before")
-    @classmethod
-    def get_secret_key(cls, value, info):
-        config_dir = info.data.get("CONFIG_DIR")
-
-        if not config_dir:
-            logger.debug("No CONFIG_DIR provided, not saving secret key")
-            return value or secrets.token_urlsafe(32)
-
-        secret_key_path = Path(config_dir) / "secret_key"
-
-        if value:
-            logger.debug("Secret key provided")
-            secret_value = value.get_secret_value() if isinstance(value, SecretStr) else value
-            write_secret_to_file(secret_key_path, secret_value)
-        else:
-            logger.debug("No secret key provided, generating a random one")
-
-            if secret_key_path.exists():
-                value = read_secret_from_file(secret_key_path)
-                logger.debug("Loaded secret key")
-                if not value:
-                    value = secrets.token_urlsafe(32)
-                    write_secret_to_file(secret_key_path, value)
-                    logger.debug("Saved secret key")
-            else:
-                value = secrets.token_urlsafe(32)
-                write_secret_to_file(secret_key_path, value)
-                logger.debug("Saved secret key")
-
-        return value if isinstance(value, SecretStr) else SecretStr(value).get_secret_value()

langflow/services/settings/constants.py

@@ -1,31 +0,0 @@
-DEFAULT_SUPERUSER = "langflow"
-DEFAULT_SUPERUSER_PASSWORD = "langflow"  # noqa: S105
-VARIABLES_TO_GET_FROM_ENVIRONMENT = [
-    "COMPOSIO_API_KEY",
-    "OPENAI_API_KEY",
-    "ANTHROPIC_API_KEY",
-    "GOOGLE_API_KEY",
-    "AZURE_OPENAI_API_KEY",
-    "AZURE_OPENAI_API_VERSION",
-    "AZURE_OPENAI_API_INSTANCE_NAME",
-    "AZURE_OPENAI_API_DEPLOYMENT_NAME",
-    "AZURE_OPENAI_API_EMBEDDINGS_DEPLOYMENT_NAME",
-    "ASTRA_DB_APPLICATION_TOKEN",
-    "ASTRA_DB_API_ENDPOINT",
-    "COHERE_API_KEY",
-    "GROQ_API_KEY",
-    "HUGGINGFACEHUB_API_TOKEN",
-    "PINECONE_API_KEY",
-    "SAMBANOVA_API_KEY",
-    "SEARCHAPI_API_KEY",
-    "SERPAPI_API_KEY",
-    "UPSTASH_VECTOR_REST_URL",
-    "UPSTASH_VECTOR_REST_TOKEN",
-    "VECTARA_CUSTOMER_ID",
-    "VECTARA_CORPUS_ID",
-    "VECTARA_API_KEY",
-    "AWS_ACCESS_KEY_ID",
-    "AWS_SECRET_ACCESS_KEY",
-    "NOVITA_API_KEY",
-    "TAVILY_API_KEY",
-]

langflow/services/settings/manager.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import yaml
-
-from langflow.logging.logger import logger
-from langflow.services.base import Service
-from langflow.services.settings.auth import AuthSettings
-from langflow.services.settings.base import Settings
-
-
-class SettingsService(Service):
-    name = "settings_service"
-
-    def __init__(self, settings: Settings, auth_settings: AuthSettings):
-        super().__init__()
-        self.settings = settings
-        self.auth_settings = auth_settings
-
-    @classmethod
-    def load_settings_from_yaml(cls, file_path: str) -> SettingsService:
-        # Check if a string is a valid path or a file name
-        if "/" not in file_path:
-            # Get current path
-            current_path = Path(__file__).resolve().parent
-            file_path_ = Path(current_path) / file_path
-        else:
-            file_path_ = Path(file_path)
-
-        with file_path_.open(encoding="utf-8") as f:
-            settings_dict = yaml.safe_load(f)
-            settings_dict = {k.upper(): v for k, v in settings_dict.items()}
-
-            for key in settings_dict:
-                if key not in Settings.model_fields:
-                    msg = f"Key {key} not found in settings"
-                    raise KeyError(msg)
-                logger.debug(f"Loading {len(settings_dict[key])} {key} from {file_path}")
-
-        settings = Settings(**settings_dict)
-        if not settings.config_dir:
-            msg = "CONFIG_DIR must be set in settings"
-            raise ValueError(msg)
-
-        auth_settings = AuthSettings(
-            CONFIG_DIR=settings.config_dir,
-        )
-        return cls(settings, auth_settings)

langflow/services/settings/utils.py

@@ -1,40 +0,0 @@
-import platform
-from pathlib import Path
-
-from langflow.logging.logger import logger
-
-
-def set_secure_permissions(file_path: Path) -> None:
-    if platform.system() in {"Linux", "Darwin"}:  # Unix/Linux/Mac
-        file_path.chmod(0o600)
-    elif platform.system() == "Windows":
-        import win32api
-        import win32con
-        import win32security
-
-        user, _, _ = win32security.LookupAccountName("", win32api.GetUserName())
-        sd = win32security.GetFileSecurity(str(file_path), win32security.DACL_SECURITY_INFORMATION)
-        dacl = win32security.ACL()
-
-        # Set the new DACL for the file: read and write access for the owner, no access for everyone else
-        dacl.AddAccessAllowedAce(
-            win32security.ACL_REVISION,
-            win32con.GENERIC_READ | win32con.GENERIC_WRITE,
-            user,
-        )
-        sd.SetSecurityDescriptorDacl(1, dacl, 0)
-        win32security.SetFileSecurity(str(file_path), win32security.DACL_SECURITY_INFORMATION, sd)
-    else:
-        logger.error("Unsupported OS")
-
-
-def write_secret_to_file(path: Path, value: str) -> None:
-    path.write_text(value, encoding="utf-8")
-    try:
-        set_secure_permissions(path)
-    except Exception:  # noqa: BLE001
-        logger.exception("Failed to set secure permissions on secret key")
-
-
-def read_secret_from_file(path: Path) -> str:
-    return path.read_text(encoding="utf-8")

langflow/template/field/prompt.py

@@ -1,2 +0,0 @@
-# This file is for backwards compatibility
-from langflow.inputs.inputs import DEFAULT_PROMPT_INTUT_TYPES, DefaultPromptField  # noqa: F401

langflow/template/frontend_node/__init__.py

@@ -1,6 +0,0 @@
-from langflow.template.frontend_node import base, custom_components
-
-__all__ = [
-    "base",
-    "custom_components",
-]

langflow/template/frontend_node/base.py

@@ -1,212 +0,0 @@
-from collections import defaultdict
-
-from pydantic import BaseModel, field_serializer, model_serializer
-
-from langflow.template.field.base import Output
-from langflow.template.template.base import Template
-
-
-class FrontendNode(BaseModel):
-    _format_template: bool = True
-    template: Template
-    """Template for the frontend node."""
-    description: str | None = None
-    """Description of the frontend node."""
-    icon: str | None = None
-    """Icon of the frontend node."""
-    is_input: bool | None = None
-    """Whether the frontend node is used as an input when processing the Graph.
-    If True, there should be a field named 'input_value'."""
-    is_output: bool | None = None
-    """Whether the frontend node is used as an output when processing the Graph.
-    If True, there should be a field named 'input_value'."""
-    is_composition: bool | None = None
-    """Whether the frontend node is used for composition."""
-    base_classes: list[str]
-    """List of base classes for the frontend node."""
-    name: str = ""
-    """Name of the frontend node."""
-    display_name: str | None = ""
-    """Display name of the frontend node."""
-    priority: int | None = None
-    """Priority of the frontend node."""
-    documentation: str = ""
-    """Documentation of the frontend node."""
-    minimized: bool = False
-    """Whether the frontend node is minimized."""
-    custom_fields: dict | None = defaultdict(list)
-    """Custom fields of the frontend node."""
-    output_types: list[str] = []
-    """List of output types for the frontend node."""
-    full_path: str | None = None
-    """Full path of the frontend node."""
-    pinned: bool = False
-    """Whether the frontend node is pinned."""
-    conditional_paths: list[str] = []
-    """List of conditional paths for the frontend node."""
-    frozen: bool = False
-    """Whether the frontend node is frozen."""
-    outputs: list[Output] = []
-    """List of output fields for the frontend node."""
-
-    field_order: list[str] = []
-    """Order of the fields in the frontend node."""
-    beta: bool = False
-    """Whether the frontend node is in beta."""
-    legacy: bool = False
-    """Whether the frontend node is legacy."""
-    error: str | None = None
-    """Error message for the frontend node."""
-    edited: bool = False
-    """Whether the frontend node has been edited."""
-    metadata: dict = {}
-    """Metadata for the component node."""
-    tool_mode: bool = False
-    """Whether the frontend node is in tool mode."""
-
-    def set_documentation(self, documentation: str) -> None:
-        """Sets the documentation of the frontend node."""
-        self.documentation = documentation
-
-    @field_serializer("base_classes")
-    def process_base_classes(self, base_classes: list[str]) -> list[str]:
-        """Removes unwanted base classes from the list of base classes."""
-        return sorted(set(base_classes), key=lambda x: x.lower())
-
-    @field_serializer("display_name")
-    def process_display_name(self, display_name: str) -> str:
-        """Sets the display name of the frontend node."""
-        return display_name or self.name
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        result = handler(self)
-        if hasattr(self, "template") and hasattr(self.template, "to_dict"):
-            result["template"] = self.template.to_dict()
-        name = result.pop("name")
-
-        # Migrate base classes to outputs
-        if "output_types" in result and not result.get("outputs"):
-            for base_class in result["output_types"]:
-                output = Output(
-                    display_name=base_class,
-                    name=base_class.lower(),
-                    types=[base_class],
-                    selected=base_class,
-                )
-                result["outputs"].append(output.model_dump())
-
-        return {name: result}
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "FrontendNode":
-        if "template" in data:
-            data["template"] = Template.from_dict(data["template"])
-        return cls(**data)
-
-    # For backwards compatibility
-    def to_dict(self, *, keep_name=True) -> dict:
-        """Returns a dict representation of the frontend node."""
-        dump = self.model_dump(by_alias=True, exclude_none=True)
-        if not keep_name:
-            return dump.pop(self.name)
-        return dump
-
-    def add_extra_fields(self) -> None:
-        pass
-
-    def add_extra_base_classes(self) -> None:
-        pass
-
-    def set_base_classes_from_outputs(self) -> None:
-        self.base_classes = [output_type for output in self.outputs for output_type in output.types]
-
-    def validate_component(self) -> None:
-        self.validate_name_overlap()
-        self.validate_attributes()
-
-    def validate_name_overlap(self) -> None:
-        # Check if any of the output names overlap with the any of the inputs
-        output_names = [output.name for output in self.outputs if not output.allows_loop]
-        input_names = [input_.name for input_ in self.template.fields]
-        overlap = set(output_names).intersection(input_names)
-        if overlap:
-            overlap_str = ", ".join(f"'{x}'" for x in overlap)
-            msg = (
-                "There should be no overlap between input and output names. "
-                f"Names {overlap_str} are duplicated in component {self.display_name}. "
-                f"Inputs are {input_names} and outputs are {output_names}."
-            )
-            raise ValueError(msg)
-
-    def validate_attributes(self) -> None:
-        # None of inputs, outputs, _artifacts, _results, logs, status, vertex, graph, display_name, description,
-        # documentation, icon should be present in outputs or input names
-        output_names = [output.name for output in self.outputs]
-        input_names = [input_.name for input_ in self.template.fields]
-        attributes = [
-            "inputs",
-            "outputs",
-            "_artifacts",
-            "_results",
-            "logs",
-            "status",
-            "vertex",
-            "graph",
-            "display_name",
-            "description",
-            "documentation",
-            "icon",
-        ]
-        output_overlap = set(output_names).intersection(attributes)
-        input_overlap = set(input_names).intersection(attributes)
-        error_message = ""
-        if output_overlap:
-            output_overlap_str = ", ".join(f"'{x}'" for x in output_overlap)
-            error_message += f"Output names {output_overlap_str} are reserved attributes.\n"
-        if input_overlap:
-            input_overlap_str = ", ".join(f"'{x}'" for x in input_overlap)
-            error_message += f"Input names {input_overlap_str} are reserved attributes."
-
-    def add_base_class(self, base_class: str | list[str]) -> None:
-        """Adds a base class to the frontend node."""
-        if isinstance(base_class, str):
-            self.base_classes.append(base_class)
-        elif isinstance(base_class, list):
-            self.base_classes.extend(base_class)
-
-    def add_output_type(self, output_type: str | list[str]) -> None:
-        """Adds an output type to the frontend node."""
-        if isinstance(output_type, str):
-            self.output_types.append(output_type)
-        elif isinstance(output_type, list):
-            self.output_types.extend(output_type)
-
-    @classmethod
-    def from_inputs(cls, **kwargs):
-        """Create a frontend node from inputs."""
-        if "inputs" not in kwargs:
-            msg = "Missing 'inputs' argument."
-            raise ValueError(msg)
-        if "_outputs_map" in kwargs:
-            kwargs["outputs"] = kwargs.pop("_outputs_map")
-        inputs = kwargs.pop("inputs")
-        template = Template(type_name="Component", fields=inputs)
-        kwargs["template"] = template
-        return cls(**kwargs)
-
-    def set_field_value_in_template(self, field_name, value) -> None:
-        for idx, field in enumerate(self.template.fields):
-            if field.name == field_name:
-                new_field = field.model_copy()
-                new_field.value = value
-                self.template.fields[idx] = new_field
-                break
-
-    def set_field_load_from_db_in_template(self, field_name, value) -> None:
-        for idx, field in enumerate(self.template.fields):
-            if field.name == field_name and hasattr(field, "load_from_db"):
-                new_field = field.model_copy()
-                new_field.load_from_db = value
-                self.template.fields[idx] = new_field
-                break

langflow/template/frontend_node/constants.py

@@ -1,65 +0,0 @@
-FORCE_SHOW_FIELDS = [
-    "allowed_tools",
-    "memory",
-    "prefix",
-    "examples",
-    "temperature",
-    "model_name",
-    "headers",
-    "max_value_length",
-    "max_tokens",
-    "google_cse_id",
-]
-
-DEFAULT_PROMPT = """
-I want you to act as a naming consultant for new companies.
-
-Here are some examples of good company names:
-
-- search engine, Google
-- social media, Facebook
-- video sharing, YouTube
-
-The name should be short, catchy and easy to remember.
-
-What is a good name for a company that makes {product}?
-"""
-
-SYSTEM_PROMPT = """
-You are a helpful assistant that talks casually about life in general.
-You are a good listener and you can talk about anything.
-"""
-
-HUMAN_PROMPT = "{input}"
-
-QA_CHAIN_TYPES = ["stuff", "map_reduce", "map_rerank", "refine"]
-
-CTRANSFORMERS_DEFAULT_CONFIG = {
-    "top_k": 40,
-    "top_p": 0.95,
-    "temperature": 0.8,
-    "repetition_penalty": 1.1,
-    "last_n_tokens": 64,
-    "seed": -1,
-    "max_new_tokens": 256,
-    "stop": None,
-    "stream": False,
-    "reset": True,
-    "batch_size": 8,
-    "threads": -1,
-    "context_length": -1,
-    "gpu_layers": 0,
-}
-
-# This variable is used to tell the user
-# that it can be changed to use other APIs
-# like Prem and LocalAI
-OPENAI_API_BASE_INFO = """
-The base URL of the OpenAI API. Defaults to https://api.openai.com/v1.
-
-You can change this to use other APIs like JinaChat, LocalAI and Prem.
-"""
-
-
-INPUT_KEY_INFO = """The variable to be used as Chat Input when more than one variable is available."""
-OUTPUT_KEY_INFO = """The variable to be used as Chat Output (e.g. answer in a ConversationalRetrievalChain)"""