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

langflow/components/Notion/list_users.py

@@ -1,77 +0,0 @@
-import requests
-from langchain.tools import StructuredTool
-from pydantic import BaseModel
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import SecretStrInput
-from langflow.schema.data import Data
-
-
-class NotionUserList(LCToolComponent):
-    display_name = "List Users "
-    description = "Retrieve users from Notion."
-    documentation = "https://docs.langflow.org/integrations/notion/list-users"
-    icon = "NotionDirectoryLoader"
-
-    inputs = [
-        SecretStrInput(
-            name="notion_secret",
-            display_name="Notion Secret",
-            info="The Notion integration token.",
-            required=True,
-        ),
-    ]
-
-    class NotionUserListSchema(BaseModel):
-        pass
-
-    def run_model(self) -> list[Data]:
-        users = self._list_users()
-        records = []
-        combined_text = ""
-
-        for user in users:
-            output = "User:\n"
-            for key, value in user.items():
-                output += f"{key.replace('_', ' ').title()}: {value}\n"
-            output += "________________________\n"
-
-            combined_text += output
-            records.append(Data(text=output, data=user))
-
-        self.status = records
-        return records
-
-    def build_tool(self) -> Tool:
-        return StructuredTool.from_function(
-            name="notion_list_users",
-            description="Retrieve users from Notion.",
-            func=self._list_users,
-            args_schema=self.NotionUserListSchema,
-        )
-
-    def _list_users(self) -> list[dict]:
-        url = "https://api.notion.com/v1/users"
-        headers = {
-            "Authorization": f"Bearer {self.notion_secret}",
-            "Notion-Version": "2022-06-28",
-        }
-
-        response = requests.get(url, headers=headers, timeout=10)
-        response.raise_for_status()
-
-        data = response.json()
-        results = data["results"]
-
-        users = []
-        for user in results:
-            user_data = {
-                "id": user["id"],
-                "type": user["type"],
-                "name": user.get("name", ""),
-                "avatar_url": user.get("avatar_url", ""),
-            }
-            users.append(user_data)
-
-        return users

langflow/components/Notion/page_content_viewer.py

@@ -1,93 +0,0 @@
-import requests
-from langchain.tools import StructuredTool
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import SecretStrInput, StrInput
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-
-
-class NotionPageContent(LCToolComponent):
-    display_name = "Page Content Viewer "
-    description = "Retrieve the content of a Notion page as plain text."
-    documentation = "https://docs.langflow.org/integrations/notion/page-content-viewer"
-    icon = "NotionDirectoryLoader"
-
-    inputs = [
-        StrInput(
-            name="page_id",
-            display_name="Page ID",
-            info="The ID of the Notion page to retrieve.",
-        ),
-        SecretStrInput(
-            name="notion_secret",
-            display_name="Notion Secret",
-            info="The Notion integration token.",
-            required=True,
-        ),
-    ]
-
-    class NotionPageContentSchema(BaseModel):
-        page_id: str = Field(..., description="The ID of the Notion page to retrieve.")
-
-    def run_model(self) -> Data:
-        result = self._retrieve_page_content(self.page_id)
-        if isinstance(result, str) and result.startswith("Error:"):
-            # An error occurred, return it as text
-            return Data(text=result)
-        # Success, return the content
-        return Data(text=result, data={"content": result})
-
-    def build_tool(self) -> Tool:
-        return StructuredTool.from_function(
-            name="notion_page_content",
-            description="Retrieve the content of a Notion page as plain text.",
-            func=self._retrieve_page_content,
-            args_schema=self.NotionPageContentSchema,
-        )
-
-    def _retrieve_page_content(self, page_id: str) -> str:
-        blocks_url = f"https://api.notion.com/v1/blocks/{page_id}/children?page_size=100"
-        headers = {
-            "Authorization": f"Bearer {self.notion_secret}",
-            "Notion-Version": "2022-06-28",
-        }
-        try:
-            blocks_response = requests.get(blocks_url, headers=headers, timeout=10)
-            blocks_response.raise_for_status()
-            blocks_data = blocks_response.json()
-            return self.parse_blocks(blocks_data.get("results", []))
-        except requests.exceptions.RequestException as e:
-            error_message = f"Error: Failed to retrieve Notion page content. {e}"
-            if hasattr(e, "response") and e.response is not None:
-                error_message += f" Status code: {e.response.status_code}, Response: {e.response.text}"
-            return error_message
-        except Exception as e:  # noqa: BLE001
-            logger.debug("Error retrieving Notion page content", exc_info=True)
-            return f"Error: An unexpected error occurred while retrieving Notion page content. {e}"
-
-    def parse_blocks(self, blocks: list) -> str:
-        content = ""
-        for block in blocks:
-            block_type = block.get("type")
-            if block_type in {"paragraph", "heading_1", "heading_2", "heading_3", "quote"}:
-                content += self.parse_rich_text(block[block_type].get("rich_text", [])) + "\n\n"
-            elif block_type in {"bulleted_list_item", "numbered_list_item"}:
-                content += self.parse_rich_text(block[block_type].get("rich_text", [])) + "\n"
-            elif block_type == "to_do":
-                content += self.parse_rich_text(block["to_do"].get("rich_text", [])) + "\n"
-            elif block_type == "code":
-                content += self.parse_rich_text(block["code"].get("rich_text", [])) + "\n\n"
-            elif block_type == "image":
-                content += f"[Image: {block['image'].get('external', {}).get('url', 'No URL')}]\n\n"
-            elif block_type == "divider":
-                content += "---\n\n"
-        return content.strip()
-
-    def parse_rich_text(self, rich_text: list) -> str:
-        return "".join(segment.get("plain_text", "") for segment in rich_text)
-
-    def __call__(self, *args, **kwargs):
-        return self._retrieve_page_content(*args, **kwargs)

langflow/components/Notion/search.py

@@ -1,111 +0,0 @@
-from typing import Any
-
-import requests
-from langchain.tools import StructuredTool
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import DropdownInput, SecretStrInput, StrInput
-from langflow.schema.data import Data
-
-
-class NotionSearch(LCToolComponent):
-    display_name: str = "Search "
-    description: str = "Searches all pages and databases that have been shared with an integration."
-    documentation: str = "https://docs.langflow.org/integrations/notion/search"
-    icon = "NotionDirectoryLoader"
-
-    inputs = [
-        SecretStrInput(
-            name="notion_secret",
-            display_name="Notion Secret",
-            info="The Notion integration token.",
-            required=True,
-        ),
-        StrInput(
-            name="query",
-            display_name="Search Query",
-            info="The text that the API compares page and database titles against.",
-        ),
-        DropdownInput(
-            name="filter_value",
-            display_name="Filter Type",
-            info="Limits the results to either only pages or only databases.",
-            options=["page", "database"],
-            value="page",
-        ),
-        DropdownInput(
-            name="sort_direction",
-            display_name="Sort Direction",
-            info="The direction to sort the results.",
-            options=["ascending", "descending"],
-            value="descending",
-        ),
-    ]
-
-    class NotionSearchSchema(BaseModel):
-        query: str = Field(..., description="The search query text.")
-        filter_value: str = Field(default="page", description="Filter type: 'page' or 'database'.")
-        sort_direction: str = Field(default="descending", description="Sort direction: 'ascending' or 'descending'.")
-
-    def run_model(self) -> list[Data]:
-        results = self._search_notion(self.query, self.filter_value, self.sort_direction)
-        records = []
-        combined_text = f"Results found: {len(results)}\n\n"
-
-        for result in results:
-            result_data = {
-                "id": result["id"],
-                "type": result["object"],
-                "last_edited_time": result["last_edited_time"],
-            }
-
-            if result["object"] == "page":
-                result_data["title_or_url"] = result["url"]
-                text = f"id: {result['id']}\ntitle_or_url: {result['url']}\n"
-            elif result["object"] == "database":
-                if "title" in result and isinstance(result["title"], list) and len(result["title"]) > 0:
-                    result_data["title_or_url"] = result["title"][0]["plain_text"]
-                    text = f"id: {result['id']}\ntitle_or_url: {result['title'][0]['plain_text']}\n"
-                else:
-                    result_data["title_or_url"] = "N/A"
-                    text = f"id: {result['id']}\ntitle_or_url: N/A\n"
-
-            text += f"type: {result['object']}\nlast_edited_time: {result['last_edited_time']}\n\n"
-            combined_text += text
-            records.append(Data(text=text, data=result_data))
-
-        self.status = records
-        return records
-
-    def build_tool(self) -> Tool:
-        return StructuredTool.from_function(
-            name="notion_search",
-            description="Search Notion pages and databases. "
-            "Input should include the search query and optionally filter type and sort direction.",
-            func=self._search_notion,
-            args_schema=self.NotionSearchSchema,
-        )
-
-    def _search_notion(
-        self, query: str, filter_value: str = "page", sort_direction: str = "descending"
-    ) -> list[dict[str, Any]]:
-        url = "https://api.notion.com/v1/search"
-        headers = {
-            "Authorization": f"Bearer {self.notion_secret}",
-            "Content-Type": "application/json",
-            "Notion-Version": "2022-06-28",
-        }
-
-        data = {
-            "query": query,
-            "filter": {"value": filter_value, "property": "object"},
-            "sort": {"direction": sort_direction, "timestamp": "last_edited_time"},
-        }
-
-        response = requests.post(url, headers=headers, json=data, timeout=10)
-        response.raise_for_status()
-
-        results = response.json()
-        return results["results"]

langflow/components/Notion/update_page_property.py

@@ -1,114 +0,0 @@
-import json
-from typing import Any
-
-import requests
-from langchain.tools import StructuredTool
-from pydantic import BaseModel, Field
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import MultilineInput, SecretStrInput, StrInput
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-
-
-class NotionPageUpdate(LCToolComponent):
-    display_name: str = "Update Page Property "
-    description: str = "Update the properties of a Notion page."
-    documentation: str = "https://docs.langflow.org/integrations/notion/page-update"
-    icon = "NotionDirectoryLoader"
-
-    inputs = [
-        StrInput(
-            name="page_id",
-            display_name="Page ID",
-            info="The ID of the Notion page to update.",
-        ),
-        MultilineInput(
-            name="properties",
-            display_name="Properties",
-            info="The properties to update on the page (as a JSON string or a dictionary).",
-        ),
-        SecretStrInput(
-            name="notion_secret",
-            display_name="Notion Secret",
-            info="The Notion integration token.",
-            required=True,
-        ),
-    ]
-
-    class NotionPageUpdateSchema(BaseModel):
-        page_id: str = Field(..., description="The ID of the Notion page to update.")
-        properties: str | dict[str, Any] = Field(
-            ..., description="The properties to update on the page (as a JSON string or a dictionary)."
-        )
-
-    def run_model(self) -> Data:
-        result = self._update_notion_page(self.page_id, self.properties)
-        if isinstance(result, str):
-            # An error occurred, return it as text
-            return Data(text=result)
-        # Success, return the updated page data
-        output = "Updated page properties:\n"
-        for prop_name, prop_value in result.get("properties", {}).items():
-            output += f"{prop_name}: {prop_value}\n"
-        return Data(text=output, data=result)
-
-    def build_tool(self) -> Tool:
-        return StructuredTool.from_function(
-            name="update_notion_page",
-            description="Update the properties of a Notion page. "
-            "IMPORTANT: Use the tool to check the Database properties for more details before using this tool.",
-            func=self._update_notion_page,
-            args_schema=self.NotionPageUpdateSchema,
-        )
-
-    def _update_notion_page(self, page_id: str, properties: str | dict[str, Any]) -> dict[str, Any] | str:
-        url = f"https://api.notion.com/v1/pages/{page_id}"
-        headers = {
-            "Authorization": f"Bearer {self.notion_secret}",
-            "Content-Type": "application/json",
-            "Notion-Version": "2022-06-28",  # Use the latest supported version
-        }
-
-        # Parse properties if it's a string
-        if isinstance(properties, str):
-            try:
-                parsed_properties = json.loads(properties)
-            except json.JSONDecodeError as e:
-                error_message = f"Invalid JSON format for properties: {e}"
-                logger.exception(error_message)
-                return error_message
-
-        else:
-            parsed_properties = properties
-
-        data = {"properties": parsed_properties}
-
-        try:
-            logger.info(f"Sending request to Notion API: URL: {url}, Data: {json.dumps(data)}")
-            response = requests.patch(url, headers=headers, json=data, timeout=10)
-            response.raise_for_status()
-            updated_page = response.json()
-
-            logger.info(f"Successfully updated Notion page. Response: {json.dumps(updated_page)}")
-        except requests.exceptions.HTTPError as e:
-            error_message = f"HTTP Error occurred: {e}"
-            if e.response is not None:
-                error_message += f"\nStatus code: {e.response.status_code}"
-                error_message += f"\nResponse body: {e.response.text}"
-            logger.exception(error_message)
-            return error_message
-        except requests.exceptions.RequestException as e:
-            error_message = f"An error occurred while making the request: {e}"
-            logger.exception(error_message)
-            return error_message
-        except Exception as e:  # noqa: BLE001
-            error_message = f"An unexpected error occurred: {e}"
-            logger.exception(error_message)
-            return error_message
-
-        return updated_page
-
-    def __call__(self, *args, **kwargs):
-        return self._update_notion_page(*args, **kwargs)

langflow/components/_importing.py

@@ -1,37 +0,0 @@
-"""Import utilities for LangFlow components."""
-
-from __future__ import annotations
-
-from importlib import import_module
-
-
-def import_mod(
-    attr_name: str,
-    module_name: str | None,
-    package: str | None,
-) -> object:
-    """Import an attribute from a module located in a package.
-
-    This utility function is used in custom __getattr__ methods within __init__.py
-    files to dynamically import attributes.
-
-    Args:
-        attr_name: The name of the attribute to import.
-        module_name: The name of the module to import from. If None, the attribute
-            is imported from the package itself.
-        package: The name of the package where the module is located.
-    """
-    if module_name == "__module__" or module_name is None:
-        try:
-            result = import_module(f".{attr_name}", package=package)
-        except ModuleNotFoundError:
-            msg = f"module '{package!r}' has no attribute {attr_name!r}"
-            raise AttributeError(msg) from None
-    else:
-        try:
-            module = import_module(f".{module_name}", package=package)
-        except ModuleNotFoundError:
-            msg = f"module '{package!r}.{module_name!r}' not found"
-            raise ImportError(msg) from None
-        result = getattr(module, attr_name)
-    return result

langflow/components/agentql/__init__.py

@@ -1,3 +0,0 @@
-from .agentql_api import AgentQL
-
-__all__ = ["AgentQL"]

langflow/components/agentql/agentql_api.py

@@ -1,151 +0,0 @@
-import httpx
-
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.io import BoolInput, DropdownInput, IntInput, MessageTextInput, MultilineInput, Output, SecretStrInput
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-
-
-class AgentQL(Component):
-    display_name = "Extract Web Data"
-    description = "Extracts structured data from a web page using an AgentQL query or a Natural Language description."
-    documentation: str = "https://docs.agentql.com/rest-api/api-reference"
-    icon = "AgentQL"
-    name = "AgentQL"
-
-    inputs = [
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            required=True,
-            password=True,
-            info="Your AgentQL API key from dev.agentql.com",
-        ),
-        MessageTextInput(
-            name="url",
-            display_name="URL",
-            required=True,
-            info="The URL of the public web page you want to extract data from.",
-            tool_mode=True,
-        ),
-        MultilineInput(
-            name="query",
-            display_name="AgentQL Query",
-            required=False,
-            info="The AgentQL query to execute. Learn more at https://docs.agentql.com/agentql-query or use a prompt.",
-            tool_mode=True,
-        ),
-        MultilineInput(
-            name="prompt",
-            display_name="Prompt",
-            required=False,
-            info="A Natural Language description of the data to extract from the page. Alternative to AgentQL query.",
-            tool_mode=True,
-        ),
-        BoolInput(
-            name="is_stealth_mode_enabled",
-            display_name="Enable Stealth Mode (Beta)",
-            info="Enable experimental anti-bot evasion strategies. May not work for all websites at all times.",
-            value=False,
-            advanced=True,
-        ),
-        IntInput(
-            name="timeout",
-            display_name="Timeout",
-            info="Seconds to wait for a request.",
-            value=900,
-            advanced=True,
-        ),
-        DropdownInput(
-            name="mode",
-            display_name="Request Mode",
-            info="'standard' uses deep data analysis, while 'fast' trades some depth of analysis for speed.",
-            options=["fast", "standard"],
-            value="fast",
-            advanced=True,
-        ),
-        IntInput(
-            name="wait_for",
-            display_name="Wait For",
-            info="Seconds to wait for the page to load before extracting data.",
-            value=0,
-            range_spec=RangeSpec(min=0, max=10, step_type="int"),
-            advanced=True,
-        ),
-        BoolInput(
-            name="is_scroll_to_bottom_enabled",
-            display_name="Enable scroll to bottom",
-            info="Scroll to bottom of the page before extracting data.",
-            value=False,
-            advanced=True,
-        ),
-        BoolInput(
-            name="is_screenshot_enabled",
-            display_name="Enable screenshot",
-            info="Take a screenshot before extracting data. Returned in 'metadata' as a Base64 string.",
-            value=False,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data", name="data", method="build_output"),
-    ]
-
-    def build_output(self) -> Data:
-        endpoint = "https://api.agentql.com/v1/query-data"
-        headers = {
-            "X-API-Key": self.api_key,
-            "Content-Type": "application/json",
-            "X-TF-Request-Origin": "langflow",
-        }
-
-        payload = {
-            "url": self.url,
-            "query": self.query,
-            "prompt": self.prompt,
-            "params": {
-                "mode": self.mode,
-                "wait_for": self.wait_for,
-                "is_scroll_to_bottom_enabled": self.is_scroll_to_bottom_enabled,
-                "is_screenshot_enabled": self.is_screenshot_enabled,
-            },
-            "metadata": {
-                "experimental_stealth_mode_enabled": self.is_stealth_mode_enabled,
-            },
-        }
-
-        if not self.prompt and not self.query:
-            self.status = "Either Query or Prompt must be provided."
-            raise ValueError(self.status)
-        if self.prompt and self.query:
-            self.status = "Both Query and Prompt can't be provided at the same time."
-            raise ValueError(self.status)
-
-        try:
-            response = httpx.post(endpoint, headers=headers, json=payload, timeout=self.timeout)
-            response.raise_for_status()
-
-            json = response.json()
-            data = Data(result=json["data"], metadata=json["metadata"])
-
-        except httpx.HTTPStatusError as e:
-            response = e.response
-            if response.status_code == httpx.codes.UNAUTHORIZED:
-                self.status = "Please, provide a valid API Key. You can create one at https://dev.agentql.com."
-            else:
-                try:
-                    error_json = response.json()
-                    logger.error(
-                        f"Failure response: '{response.status_code} {response.reason_phrase}' with body: {error_json}"
-                    )
-                    msg = error_json["error_info"] if "error_info" in error_json else error_json["detail"]
-                except (ValueError, TypeError):
-                    msg = f"HTTP {e}."
-                self.status = msg
-            raise ValueError(self.status) from e
-
-        else:
-            self.status = data
-            return data

langflow/components/agents/__init__.py

@@ -1,4 +0,0 @@
-from .agent import AgentComponent
-from .mcp_component import MCPToolsComponent
-
-__all__ = ["AgentComponent", "MCPToolsComponent"]