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

langflow_base_nightly-0.0.96.dev3/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: langflow-base-nightly
+Version: 0.0.96.dev3
+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.dev3/langflow/base/textsplitters/model.py

@@ -0,0 +1,29 @@
+from abc import abstractmethod
+
+from langchain_core.documents import BaseDocumentTransformer
+from langchain_text_splitters import TextSplitter
+
+from langflow.base.document_transformers.model import LCDocumentTransformerComponent
+
+
+class LCTextSplitterComponent(LCDocumentTransformerComponent):
+    trace_type = "text_splitter"
+
+    def _validate_outputs(self):
+        required_output_methods = ["text_splitter"]
+        output_names = [output.name for output in self.outputs]
+        for method_name in required_output_methods:
+            if method_name not in output_names:
+                raise ValueError(f"Output with name '{method_name}' must be defined.")
+            elif not hasattr(self, method_name):
+                raise ValueError(f"Method '{method_name}' must be defined.")
+
+    def build_document_transformer(self) -> BaseDocumentTransformer:
+        return self.build_text_splitter()
+
+    @abstractmethod
+    def build_text_splitter(self) -> TextSplitter:
+        """
+        Build the text splitter.
+        """
+        pass

langflow_base_nightly-0.0.96.dev3/langflow/base/tools/flow_tool.py

@@ -0,0 +1,114 @@
+from typing import Any, List, Optional, Type
+
+from asyncer import syncify
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import BaseTool, ToolException
+from pydantic.v1 import BaseModel
+
+from langflow.base.flow_processing.utils import build_data_from_result_data, format_flow_output_data
+from langflow.graph.graph.base import Graph
+from langflow.graph.vertex.base import Vertex
+from langflow.helpers.flow import build_schema_from_inputs, get_arg_names, get_flow_inputs, run_flow
+
+
+class FlowTool(BaseTool):
+    name: str
+    description: str
+    graph: Optional[Graph] = None
+    flow_id: Optional[str] = None
+    user_id: Optional[str] = None
+    inputs: List["Vertex"] = []
+    get_final_results_only: bool = True
+
+    @property
+    def args(self) -> dict:
+        schema = self.get_input_schema()
+        return schema.schema()["properties"]
+
+    def get_input_schema(self, config: Optional[RunnableConfig] = None) -> Type[BaseModel]:
+        """The tool's input schema."""
+        if self.args_schema is not None:
+            return self.args_schema
+        elif self.graph is not None:
+            return build_schema_from_inputs(self.name, get_flow_inputs(self.graph))
+        else:
+            raise ToolException("No input schema available.")
+
+    def _run(
+        self,
+        *args: Any,
+        **kwargs: Any,
+    ) -> str:
+        """Use the tool."""
+        args_names = get_arg_names(self.inputs)
+        if len(args_names) == len(args):
+            kwargs = {arg["arg_name"]: arg_value for arg, arg_value in zip(args_names, args)}
+        elif len(args_names) != len(args) and len(args) != 0:
+            raise ToolException(
+                "Number of arguments does not match the number of inputs. Pass keyword arguments instead."
+            )
+        tweaks = {arg["component_name"]: kwargs[arg["arg_name"]] for arg in args_names}
+
+        run_outputs = syncify(run_flow, raise_sync_error=False)(
+            tweaks={key: {"input_value": value} for key, value in tweaks.items()},
+            flow_id=self.flow_id,
+            user_id=self.user_id,
+        )
+        if not run_outputs:
+            return "No output"
+        run_output = run_outputs[0]
+
+        data = []
+        if run_output is not None:
+            for output in run_output.outputs:
+                if output:
+                    data.extend(build_data_from_result_data(output, get_final_results_only=self.get_final_results_only))
+        return format_flow_output_data(data)
+
+    def validate_inputs(self, args_names: List[dict[str, str]], args: Any, kwargs: Any):
+        """Validate the inputs."""
+
+        if len(args) > 0 and len(args) != len(args_names):
+            raise ToolException(
+                "Number of positional arguments does not match the number of inputs. Pass keyword arguments instead."
+            )
+
+        if len(args) == len(args_names):
+            kwargs = {arg_name["arg_name"]: arg_value for arg_name, arg_value in zip(args_names, args)}
+
+        missing_args = [arg["arg_name"] for arg in args_names if arg["arg_name"] not in kwargs]
+        if missing_args:
+            raise ToolException(f"Missing required arguments: {', '.join(missing_args)}")
+
+        return kwargs
+
+    def build_tweaks_dict(self, args, kwargs):
+        args_names = get_arg_names(self.inputs)
+        kwargs = self.validate_inputs(args_names=args_names, args=args, kwargs=kwargs)
+        tweaks = {arg["component_name"]: kwargs[arg["arg_name"]] for arg in args_names}
+        return tweaks
+
+    async def _arun(
+        self,
+        *args: Any,
+        **kwargs: Any,
+    ) -> str:
+        """Use the tool asynchronously."""
+        tweaks = self.build_tweaks_dict(args, kwargs)
+        run_id = self.graph.run_id if self.graph else None
+        run_outputs = await run_flow(
+            tweaks={key: {"input_value": value} for key, value in tweaks.items()},
+            flow_id=self.flow_id,
+            user_id=self.user_id,
+            run_id=run_id,
+        )
+        if not run_outputs:
+            return "No output"
+        run_output = run_outputs[0]
+
+        data = []
+        if run_output is not None:
+            for output in run_output.outputs:
+                if output:
+                    data.extend(build_data_from_result_data(output, get_final_results_only=self.get_final_results_only))
+        return format_flow_output_data(data)

langflow_base_nightly-0.0.96.dev3/langflow/components/tools/DuckDuckGoSearchRun.py

@@ -0,0 +1,69 @@
+from typing import Dict, Any, List
+from pydantic import BaseModel, Field
+from langchain_community.tools import DuckDuckGoSearchRun
+from langflow.base.langchain_utilities.model import LCToolComponent
+from langflow.inputs import MessageTextInput, IntInput
+from langflow.schema import Data
+from langflow.field_typing import Tool
+from langchain.tools import StructuredTool
+
+
+class DuckDuckGoSearchComponent(LCToolComponent):
+    display_name: str = "DuckDuckGo Search"
+    description: str = "Perform web searches using the DuckDuckGo search engine with result limiting"
+    name = "DuckDuckGoSearch"
+    documentation: str = "https://python.langchain.com/docs/integrations/tools/ddg"
+    icon: str = "DuckDuckGo"
+    inputs = [
+        MessageTextInput(
+            name="input_value",
+            display_name="Search Query",
+            required=True,
+        ),
+        IntInput(name="max_results", display_name="Max Results", value=5, advanced=True),
+        IntInput(name="max_snippet_length", display_name="Max Snippet Length", value=100, advanced=True),
+    ]
+
+    class DuckDuckGoSearchSchema(BaseModel):
+        query: str = Field(..., description="The search query")
+        max_results: int = Field(5, description="Maximum number of results to return")
+        max_snippet_length: int = Field(100, description="Maximum length of each result snippet")
+
+    def _build_wrapper(self):
+        return DuckDuckGoSearchRun()
+
+    def build_tool(self) -> Tool:
+        wrapper = self._build_wrapper()
+
+        def search_func(query: str, max_results: int = 5, max_snippet_length: int = 100) -> List[Dict[str, Any]]:
+            full_results = wrapper.run(f"{query} (site:*)")
+            result_list = full_results.split("\n")[:max_results]
+            limited_results = []
+            for result in result_list:
+                limited_result = {
+                    "snippet": result[:max_snippet_length],
+                }
+                limited_results.append(limited_result)
+            return limited_results
+
+        tool = StructuredTool.from_function(
+            name="duckduckgo_search",
+            description="Search for recent results using DuckDuckGo with result limiting",
+            func=search_func,
+            args_schema=self.DuckDuckGoSearchSchema,
+        )
+        self.status = "DuckDuckGo Search Tool created"
+        return tool
+
+    def run_model(self) -> List[Data]:
+        tool = self.build_tool()
+        results = tool.run(
+            {
+                "query": self.input_value,
+                "max_results": self.max_results,
+                "max_snippet_length": self.max_snippet_length,
+            }
+        )
+        data_list = [Data(data=result, text=result.get("snippet", "")) for result in results]
+        self.status = data_list
+        return data_list