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

langflow/base/agents/utils.py

@@ -1,205 +0,0 @@
-import re
-from collections.abc import Callable, Sequence
-from typing import Any
-
-from langchain.agents import (
-    create_json_chat_agent,
-    create_openai_tools_agent,
-    create_tool_calling_agent,
-    create_xml_agent,
-)
-from langchain.agents.xml.base import render_text_description
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.messages import BaseMessage
-from langchain_core.prompts import BasePromptTemplate, ChatPromptTemplate
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-from langflow.logging import logger
-from langflow.schema.data import Data
-from langflow.services.cache.base import CacheService
-from langflow.services.cache.utils import CacheMiss
-
-from .default_prompts import XML_AGENT_PROMPT
-
-
-class AgentSpec(BaseModel):
-    func: Callable[
-        [
-            BaseLanguageModel,
-            Sequence[BaseTool],
-            BasePromptTemplate | ChatPromptTemplate,
-            Callable[[list[BaseTool]], str] | None,
-            bool | list[str] | None,
-        ],
-        Any,
-    ]
-    prompt: Any | None = None
-    fields: list[str]
-    hub_repo: str | None = None
-
-
-def data_to_messages(data: list[Data]) -> list[BaseMessage]:
-    """Convert a list of data to a list of messages.
-
-    Args:
-        data (List[Data]): The data to convert.
-
-    Returns:
-        List[Message]: The data as messages.
-    """
-    return [value.to_lc_message() for value in data]
-
-
-def validate_and_create_xml_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: BasePromptTemplate,
-    tools_renderer: Callable[[list[BaseTool]], str] = render_text_description,
-    *,
-    stop_sequence: bool | list[str] = True,
-):
-    return create_xml_agent(
-        llm=llm,
-        tools=tools,
-        prompt=prompt,
-        tools_renderer=tools_renderer,
-        stop_sequence=stop_sequence,
-    )
-
-
-def validate_and_create_openai_tools_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    _tools_renderer: Callable[[list[BaseTool]], str] = render_text_description,
-    *,
-    _stop_sequence: bool | list[str] = True,
-):
-    return create_openai_tools_agent(
-        llm=llm,
-        tools=tools,
-        prompt=prompt,
-    )
-
-
-def validate_and_create_tool_calling_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    _tools_renderer: Callable[[list[BaseTool]], str] = render_text_description,
-    *,
-    _stop_sequence: bool | list[str] = True,
-):
-    return create_tool_calling_agent(
-        llm=llm,
-        tools=tools,
-        prompt=prompt,
-    )
-
-
-def validate_and_create_json_chat_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    tools_renderer: Callable[[list[BaseTool]], str] = render_text_description,
-    *,
-    stop_sequence: bool | list[str] = True,
-):
-    return create_json_chat_agent(
-        llm=llm,
-        tools=tools,
-        prompt=prompt,
-        tools_renderer=tools_renderer,
-        stop_sequence=stop_sequence,
-    )
-
-
-AGENTS: dict[str, AgentSpec] = {
-    "Tool Calling Agent": AgentSpec(
-        func=validate_and_create_tool_calling_agent,
-        prompt=None,
-        fields=["llm", "tools", "prompt"],
-        hub_repo=None,
-    ),
-    "XML Agent": AgentSpec(
-        func=validate_and_create_xml_agent,
-        prompt=XML_AGENT_PROMPT,  # Ensure XML_AGENT_PROMPT is properly defined and typed.
-        fields=["llm", "tools", "prompt", "tools_renderer", "stop_sequence"],
-        hub_repo="hwchase17/xml-agent-convo",
-    ),
-    "OpenAI Tools Agent": AgentSpec(
-        func=validate_and_create_openai_tools_agent,
-        prompt=None,
-        fields=["llm", "tools", "prompt"],
-        hub_repo=None,
-    ),
-    "JSON Chat Agent": AgentSpec(
-        func=validate_and_create_json_chat_agent,
-        prompt=None,
-        fields=["llm", "tools", "prompt", "tools_renderer", "stop_sequence"],
-        hub_repo="hwchase17/react-chat-json",
-    ),
-}
-
-
-def get_agents_list():
-    return list(AGENTS.keys())
-
-
-def safe_cache_get(cache: CacheService, key, default=None):
-    """Safely get a value from cache, handling CacheMiss objects."""
-    try:
-        value = cache.get(key)
-        if isinstance(value, CacheMiss):
-            return default
-    except (AttributeError, KeyError, TypeError):
-        return default
-    else:
-        return value
-
-
-def safe_cache_set(cache: CacheService, key, value):
-    """Safely set a value in cache, handling potential errors."""
-    try:
-        cache.set(key, value)
-    except (AttributeError, TypeError) as e:
-        logger.warning(f"Failed to set cache key '{key}': {e}")
-
-
-def maybe_unflatten_dict(flat: dict[str, Any]) -> dict[str, Any]:
-    """If any key looks nested (contains a dot or "[index]"), rebuild the.
-
-    full nested structure; otherwise return flat as is.
-    """
-    # Quick check: do we have any nested keys?
-    if not any(re.search(r"\.|\[\d+\]", key) for key in flat):
-        return flat
-
-    # Otherwise, unflatten into dicts/lists
-    nested: dict[str, Any] = {}
-    array_re = re.compile(r"^(.+)\[(\d+)\]$")
-
-    for key, val in flat.items():
-        parts = key.split(".")
-        cur = nested
-        for i, part in enumerate(parts):
-            m = array_re.match(part)
-            # Array segment?
-            if m:
-                name, idx = m.group(1), int(m.group(2))
-                lst = cur.setdefault(name, [])
-                # Ensure list is big enough
-                while len(lst) <= idx:
-                    lst.append({})
-                if i == len(parts) - 1:
-                    lst[idx] = val
-                else:
-                    cur = lst[idx]
-            # Normal object key
-            elif i == len(parts) - 1:
-                cur[part] = val
-            else:
-                cur = cur.setdefault(part, {})
-
-    return nested

langflow/base/astra_assistants/util.py

@@ -1,171 +0,0 @@
-import importlib
-import inspect
-import json
-import os
-import pkgutil
-import threading
-import uuid
-from json.decoder import JSONDecodeError
-from pathlib import Path
-from typing import Any
-
-import astra_assistants.tools as astra_assistants_tools
-import requests
-from astra_assistants import OpenAIWithDefaultKey, patch
-from astra_assistants.tools.tool_interface import ToolInterface
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-from requests.exceptions import RequestException
-
-from langflow.base.mcp.util import create_input_schema_from_json_schema
-from langflow.services.cache.utils import CacheMiss
-
-client_lock = threading.Lock()
-client = None
-
-
-def get_patched_openai_client(shared_component_cache):
-    os.environ["ASTRA_ASSISTANTS_QUIET"] = "true"
-    client = shared_component_cache.get("client")
-    if isinstance(client, CacheMiss):
-        client = patch(OpenAIWithDefaultKey())
-        shared_component_cache.set("client", client)
-    return client
-
-
-url = "https://raw.githubusercontent.com/BerriAI/litellm/refs/heads/main/model_prices_and_context_window.json"
-try:
-    response = requests.get(url, timeout=10)
-    response.raise_for_status()
-    data = json.loads(response.text)
-except RequestException:
-    data = {}
-except JSONDecodeError:
-    data = {}
-
-# Extract the model names into a Python list
-litellm_model_names = [model for model in data if model != "sample_spec"]
-
-
-# To store the class names that extend ToolInterface
-tool_names = []
-tools_and_names = {}
-
-
-def tools_from_package(your_package) -> None:
-    # Iterate over all modules in the package
-    package_name = your_package.__name__
-    for module_info in pkgutil.iter_modules(your_package.__path__):
-        module_name = f"{package_name}.{module_info.name}"
-
-        # Dynamically import the module
-        import warnings
-
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore", message="Support for class-based `config` is deprecated", category=DeprecationWarning
-            )
-            warnings.filterwarnings("ignore", message="Valid config keys have changed in V2", category=UserWarning)
-            module = importlib.import_module(module_name)
-
-        # Iterate over all members of the module
-        for name, obj in inspect.getmembers(module, inspect.isclass):
-            # Check if the class is a subclass of ToolInterface and is not ToolInterface itself
-            if issubclass(obj, ToolInterface) and obj is not ToolInterface:
-                tool_names.append(name)
-                tools_and_names[name] = obj
-
-
-tools_from_package(astra_assistants_tools)
-
-
-def wrap_base_tool_as_tool_interface(base_tool: BaseTool) -> ToolInterface:
-    """wrap_Base_tool_ass_tool_interface.
-
-    Wrap a BaseTool instance in a new class implementing ToolInterface,
-    building a dynamic Pydantic model from its args_schema (if any).
-    We only call `args_schema()` if it's truly a function/method,
-    avoiding accidental calls on a Pydantic model class (which is also callable).
-    """
-    raw_args_schema = getattr(base_tool, "args_schema", None)
-
-    # --- 1) Distinguish between a function/method vs. class/dict/None ---
-    if inspect.isfunction(raw_args_schema) or inspect.ismethod(raw_args_schema):
-        # It's actually a function -> call it once to get a class or dict
-        raw_args_schema = raw_args_schema()
-    # Otherwise, if it's a class or dict, do nothing here
-
-    # Now `raw_args_schema` might be:
-    # - A Pydantic model class (subclass of BaseModel)
-    # - A dict (JSON schema)
-    # - None
-    # - Something unexpected => raise error
-
-    # --- 2) Convert the schema or model class to a JSON schema dict ---
-    if raw_args_schema is None:
-        # No schema => minimal
-        schema_dict = {"type": "object", "properties": {}}
-
-    elif isinstance(raw_args_schema, dict):
-        # Already a JSON schema
-        schema_dict = raw_args_schema
-
-    elif inspect.isclass(raw_args_schema) and issubclass(raw_args_schema, BaseModel):
-        # It's a Pydantic model class -> convert to JSON schema
-        schema_dict = raw_args_schema.schema()
-
-    else:
-        msg = f"args_schema must be a Pydantic model class, a JSON schema dict, or None. Got: {raw_args_schema!r}"
-        raise TypeError(msg)
-
-    # --- 3) Build our dynamic Pydantic model from the JSON schema ---
-    InputSchema: type[BaseModel] = create_input_schema_from_json_schema(schema_dict)  # noqa: N806
-
-    # --- 4) Define a wrapper class that uses composition ---
-    class WrappedDynamicTool(ToolInterface):
-        """WrappedDynamicTool.
-
-        Uses composition to delegate logic to the original base_tool,
-        but sets `call(..., arguments: InputSchema)` so we have a real model.
-        """
-
-        def __init__(self, tool: BaseTool):
-            self._tool = tool
-
-        def call(self, arguments: InputSchema) -> dict:  # type: ignore # noqa: PGH003
-            output = self._tool.invoke(arguments.dict())  # type: ignore # noqa: PGH003
-            result = ""
-            if "error" in output[0].data:
-                result = output[0].data["error"]
-            elif "result" in output[0].data:
-                result = output[0].data["result"]
-            return {"cache_id": str(uuid.uuid4()), "output": result}
-
-        def run(self, tool_input: Any) -> str:
-            return self._tool.run(tool_input)
-
-        def name(self) -> str:
-            """Return the base tool's name if it exists."""
-            if hasattr(self._tool, "name"):
-                return str(self._tool.name)
-            return super().name()
-
-        def to_function(self):
-            """Incorporate the base tool's description if present."""
-            params = InputSchema.schema()
-            description = getattr(self._tool, "description", "A dynamically wrapped tool")
-            return {
-                "type": "function",
-                "function": {"name": self.name(), "description": description, "parameters": params},
-            }
-
-    # Return an instance of our newly minted class
-    return WrappedDynamicTool(base_tool)
-
-
-def sync_upload(file_path, client):
-    with Path(file_path).open("rb") as sync_file_handle:
-        return client.files.create(
-            file=sync_file_handle,  # Pass the sync file handle
-            purpose="assistants",
-        )

langflow/base/chains/model.py

@@ -1,19 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.template.field.base import Output
-
-
-class LCChainComponent(Component):
-    trace_type = "chain"
-
-    outputs = [Output(display_name="Text", name="text", method="invoke_chain")]
-
-    def _validate_outputs(self) -> None:
-        required_output_methods = ["invoke_chain"]
-        output_names = [output.name for output in self.outputs]
-        for method_name in required_output_methods:
-            if method_name not in output_names:
-                msg = f"Output with name '{method_name}' must be defined."
-                raise ValueError(msg)
-            if not hasattr(self, method_name):
-                msg = f"Method '{method_name}' must be defined."
-                raise ValueError(msg)