langflow-base-nightly 0.0.96.dev1__tar.gz → 0.0.96.dev4__tar.gz

langflow_base_nightly-0.0.96.dev4/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: langflow-base-nightly
+Version: 0.0.96.dev4
+Summary: A Python package with a built-in web application
+Home-page: https://github.com/langflow-ai/langflow
+License: MIT
+Keywords: nlp,langchain,openai,gpt,gui
+Author: Langflow
+Author-email: contact@langflow.org
+Maintainer: Carlos Coelho
+Maintainer-email: carlos@langflow.org
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: all
+Provides-Extra: deploy
+Provides-Extra: local
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
+Requires-Dist: alembic (>=1.13.0,<2.0.0)
+Requires-Dist: asyncer (>=0.0.5,<0.0.6)
+Requires-Dist: bcrypt (==4.0.1)
+Requires-Dist: cachetools (>=5.3.1,<6.0.0)
+Requires-Dist: chardet (>=5.2.0,<6.0.0)
+Requires-Dist: clickhouse-connect (==0.7.19)
+Requires-Dist: crewai (>=0.36.0,<0.37.0)
+Requires-Dist: cryptography (>=42.0.5,<44.0.0)
+Requires-Dist: diskcache (>=5.6.3,<6.0.0)
+Requires-Dist: docstring-parser (>=0.16,<0.17)
+Requires-Dist: duckdb (>=1.0.0,<2.0.0)
+Requires-Dist: emoji (>=2.12.0,<3.0.0)
+Requires-Dist: fastapi (>=0.111.0,<0.112.0)
+Requires-Dist: filelock (>=3.15.4,<4.0.0)
+Requires-Dist: firecrawl-py (>=0.0.16,<0.0.17)
+Requires-Dist: grandalf (>=0.8.0,<0.9.0)
+Requires-Dist: gunicorn (>=22.0.0,<23.0.0)
+Requires-Dist: httpx
+Requires-Dist: jq (>=1.7.0,<2.0.0) ; sys_platform != "win32"
+Requires-Dist: langchain (>=0.2.0,<0.3.0)
+Requires-Dist: langchain-core (>=0.2.32,<0.3.0)
+Requires-Dist: langchain-experimental (>=0.0.61,<0.0.62)
+Requires-Dist: langchainhub (>=0.1.15,<0.2.0)
+Requires-Dist: loguru (>=0.7.1,<0.8.0)
+Requires-Dist: multiprocess (>=0.70.14,<0.71.0)
+Requires-Dist: nanoid (>=2.0.0,<3.0.0)
+Requires-Dist: nest-asyncio (>=1.6.0,<2.0.0)
+Requires-Dist: opentelemetry-api (>=1.25.0,<2.0.0)
+Requires-Dist: opentelemetry-exporter-prometheus (>=0.46b0,<0.47)
+Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.46b0,<0.47)
+Requires-Dist: opentelemetry-sdk (>=1.25.0,<2.0.0)
+Requires-Dist: orjson (==3.10.0)
+Requires-Dist: pandas (==2.2.2)
+Requires-Dist: passlib (>=1.7.4,<2.0.0)
+Requires-Dist: pillow (>=10.2.0,<11.0.0)
+Requires-Dist: platformdirs (>=4.2.0,<5.0.0)
+Requires-Dist: prometheus-client (>=0.20.0,<0.21.0)
+Requires-Dist: pydantic (>=2.7.0,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.2.0,<3.0.0)
+Requires-Dist: pypdf (>=4.2.0,<5.0.0)
+Requires-Dist: pyperclip (>=1.8.2,<2.0.0)
+Requires-Dist: python-docx (>=1.1.0,<2.0.0)
+Requires-Dist: python-jose (>=3.3.0,<4.0.0)
+Requires-Dist: python-multipart (>=0.0.7,<0.0.8)
+Requires-Dist: rich (>=13.7.0,<14.0.0)
+Requires-Dist: sentry-sdk[fastapi,loguru] (>=2.5.1,<3.0.0)
+Requires-Dist: setuptools (>=70)
+Requires-Dist: spider-client (>=0.0.27,<0.0.28)
+Requires-Dist: sqlmodel (>=0.0.18,<0.0.19)
+Requires-Dist: typer (>=0.12.0,<0.13.0)
+Requires-Dist: uncurl (>=0.0.11,<0.0.12)
+Requires-Dist: uvicorn (>=0.30.0,<0.31.0)
+Requires-Dist: websockets
+Project-URL: Documentation, https://docs.langflow.org
+Project-URL: Repository, https://github.com/langflow-ai/langflow
+Description-Content-Type: text/markdown
+
+

langflow_base_nightly-0.0.96.dev4/langflow/api/utils.py

@@ -0,0 +1,255 @@
+import uuid
+import warnings
+from typing import TYPE_CHECKING, Any
+
+from fastapi import HTTPException
+from langflow.services.database.models.transactions.model import TransactionTable
+from langflow.services.database.models.vertex_builds.model import VertexBuildTable
+from sqlalchemy import delete
+from sqlmodel import Session
+
+from langflow.graph.graph.base import Graph
+from langflow.services.chat.service import ChatService
+from langflow.services.database.models.flow import Flow
+from langflow.services.store.schema import StoreComponentCreate
+from langflow.services.store.utils import get_lf_version_from_pypi
+
+if TYPE_CHECKING:
+    from langflow.services.database.models.flow.model import Flow
+
+
+API_WORDS = ["api", "key", "token"]
+
+
+def has_api_terms(word: str):
+    return "api" in word and ("key" in word or ("token" in word and "tokens" not in word))
+
+
+def remove_api_keys(flow: dict):
+    """Remove api keys from flow data."""
+    if flow.get("data") and flow["data"].get("nodes"):
+        for node in flow["data"]["nodes"]:
+            node_data = node.get("data").get("node")
+            template = node_data.get("template")
+            for value in template.values():
+                if isinstance(value, dict) and has_api_terms(value["name"]) and value.get("password"):
+                    value["value"] = None
+
+    return flow
+
+
+def build_input_keys_response(langchain_object, artifacts):
+    """Build the input keys response."""
+
+    input_keys_response = {
+        "input_keys": {key: "" for key in langchain_object.input_keys},
+        "memory_keys": [],
+        "handle_keys": artifacts.get("handle_keys", []),
+    }
+
+    # Set the input keys values from artifacts
+    for key, value in artifacts.items():
+        if key in input_keys_response["input_keys"]:
+            input_keys_response["input_keys"][key] = value
+    # If the object has memory, that memory will have a memory_variables attribute
+    # memory variables should be removed from the input keys
+    if hasattr(langchain_object, "memory") and hasattr(langchain_object.memory, "memory_variables"):
+        # Remove memory variables from input keys
+        input_keys_response["input_keys"] = {
+            key: value
+            for key, value in input_keys_response["input_keys"].items()
+            if key not in langchain_object.memory.memory_variables
+        }
+        # Add memory variables to memory_keys
+        input_keys_response["memory_keys"] = langchain_object.memory.memory_variables
+
+    if hasattr(langchain_object, "prompt") and hasattr(langchain_object.prompt, "template"):
+        input_keys_response["template"] = langchain_object.prompt.template
+
+    return input_keys_response
+
+
+def validate_is_component(flows: list["Flow"]):
+    for flow in flows:
+        if not flow.data or flow.is_component is not None:
+            continue
+
+        is_component = get_is_component_from_data(flow.data)
+        if is_component is not None:
+            flow.is_component = is_component
+        else:
+            flow.is_component = len(flow.data.get("nodes", [])) == 1
+    return flows
+
+
+def get_is_component_from_data(data: dict):
+    """Returns True if the data is a component."""
+    return data.get("is_component")
+
+
+async def check_langflow_version(component: StoreComponentCreate):
+    from langflow.utils.version import get_version_info
+
+    __version__ = get_version_info()["version"]
+
+    if not component.last_tested_version:
+        component.last_tested_version = __version__
+
+    langflow_version = get_lf_version_from_pypi()
+    if langflow_version is None:
+        raise HTTPException(status_code=500, detail="Unable to verify the latest version of Langflow")
+    elif langflow_version != component.last_tested_version:
+        warnings.warn(
+            f"Your version of Langflow ({component.last_tested_version}) is outdated. "
+            f"Please update to the latest version ({langflow_version}) and try again."
+        )
+
+
+def format_elapsed_time(elapsed_time: float) -> str:
+    """Format elapsed time to a human-readable format coming from perf_counter().
+
+    - Less than 1 second: returns milliseconds
+    - Less than 1 minute: returns seconds rounded to 2 decimals
+    - 1 minute or more: returns minutes and seconds
+    """
+    if elapsed_time < 1:
+        milliseconds = int(round(elapsed_time * 1000))
+        return f"{milliseconds} ms"
+    elif elapsed_time < 60:
+        seconds = round(elapsed_time, 2)
+        unit = "second" if seconds == 1 else "seconds"
+        return f"{seconds} {unit}"
+    else:
+        minutes = int(elapsed_time // 60)
+        seconds = round(elapsed_time % 60, 2)
+        minutes_unit = "minute" if minutes == 1 else "minutes"
+        seconds_unit = "second" if seconds == 1 else "seconds"
+        return f"{minutes} {minutes_unit}, {seconds} {seconds_unit}"
+
+
+async def build_graph_from_data(flow_id: str, payload: dict, **kwargs):
+    """Build and cache the graph."""
+    graph = Graph.from_payload(payload, flow_id, **kwargs)
+    for vertex_id in graph._has_session_id_vertices:
+        vertex = graph.get_vertex(vertex_id)
+        if vertex is None:
+            raise ValueError(f"Vertex {vertex_id} not found")
+        if not vertex._raw_params.get("session_id"):
+            vertex.update_raw_params({"session_id": flow_id}, overwrite=True)
+
+    run_id = uuid.uuid4()
+    graph.set_run_id(run_id)
+    graph.set_run_name()
+    await graph.initialize_run()
+    return graph
+
+
+async def build_graph_from_db_no_cache(flow_id: str, session: Session):
+    """Build and cache the graph."""
+    flow: Flow | None = session.get(Flow, flow_id)
+    if not flow or not flow.data:
+        raise ValueError("Invalid flow ID")
+    return await build_graph_from_data(flow_id, flow.data, flow_name=flow.name, user_id=str(flow.user_id))
+
+
+async def build_graph_from_db(flow_id: str, session: Session, chat_service: "ChatService"):
+    graph = await build_graph_from_db_no_cache(flow_id, session)
+    await chat_service.set_cache(flow_id, graph)
+    return graph
+
+
+async def build_and_cache_graph_from_data(
+    flow_id: str,
+    chat_service: "ChatService",
+    graph_data: dict,
+):  # -> Graph | Any:
+    """Build and cache the graph."""
+    graph = Graph.from_payload(graph_data, flow_id)
+    await chat_service.set_cache(flow_id, graph)
+    return graph
+
+
+def format_syntax_error_message(exc: SyntaxError) -> str:
+    """Format a SyntaxError message for returning to the frontend."""
+    if exc.text is None:
+        return f"Syntax error in code. Error on line {exc.lineno}"
+    return f"Syntax error in code. Error on line {exc.lineno}: {exc.text.strip()}"
+
+
+def get_causing_exception(exc: BaseException) -> BaseException:
+    """Get the causing exception from an exception."""
+    if hasattr(exc, "__cause__") and exc.__cause__:
+        return get_causing_exception(exc.__cause__)
+    return exc
+
+
+def format_exception_message(exc: Exception) -> str:
+    """Format an exception message for returning to the frontend."""
+    # We need to check if the __cause__ is a SyntaxError
+    # If it is, we need to return the message of the SyntaxError
+    causing_exception = get_causing_exception(exc)
+    if isinstance(causing_exception, SyntaxError):
+        return format_syntax_error_message(causing_exception)
+    return str(exc)
+
+
+def get_top_level_vertices(graph, vertices_ids):
+    """
+    Retrieves the top-level vertices from the given graph based on the provided vertex IDs.
+
+    Args:
+        graph (Graph): The graph object containing the vertices.
+        vertices_ids (list): A list of vertex IDs.
+
+    Returns:
+        list: A list of top-level vertex IDs.
+
+    """
+    top_level_vertices = []
+    for vertex_id in vertices_ids:
+        vertex = graph.get_vertex(vertex_id)
+        if vertex.parent_is_top_level:
+            top_level_vertices.append(vertex.parent_node_id)
+        else:
+            top_level_vertices.append(vertex_id)
+    return top_level_vertices
+
+
+def parse_exception(exc):
+    """Parse the exception message."""
+    if hasattr(exc, "body"):
+        return exc.body["message"]
+    return str(exc)
+
+
+def get_suggestion_message(outdated_components: list[str]) -> str:
+    """Get the suggestion message for the outdated components."""
+    count = len(outdated_components)
+    if count == 0:
+        return "The flow contains no outdated components."
+    elif count == 1:
+        return f"The flow contains 1 outdated component. We recommend updating the following component: {outdated_components[0]}."
+    else:
+        components = ", ".join(outdated_components)
+        return f"The flow contains {count} outdated components. We recommend updating the following components: {components}."
+
+
+def parse_value(value: Any, input_type: str) -> Any:
+    """Helper function to parse the value based on input type."""
+    if value == "":
+        return value
+    elif input_type == "IntInput":
+        return int(value) if value is not None else None
+    elif input_type == "FloatInput":
+        return float(value) if value is not None else None
+    else:
+        return value
+
+
+async def cascade_delete_flow(session: Session, flow: Flow):
+    try:
+        session.exec(delete(TransactionTable).where(TransactionTable.flow_id == flow.id))  # type: ignore
+        session.exec(delete(VertexBuildTable).where(VertexBuildTable.flow_id == flow.id))  # type: ignore
+        session.exec(delete(Flow).where(Flow.id == flow.id))  # type: ignore
+    except Exception as e:
+        raise RuntimeError(f"Unable to cascade delete flow: ${flow.id}", e)