lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/Notion/list_users.py

@@ -0,0 +1,77 @@
+import requests
+from langchain.tools import StructuredTool
+from pydantic import BaseModel
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import SecretStrInput
+from lfx.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

lfx/components/Notion/page_content_viewer.py

@@ -0,0 +1,93 @@
+import requests
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import SecretStrInput, StrInput
+from lfx.log.logger import logger
+from lfx.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)

lfx/components/Notion/search.py

@@ -0,0 +1,111 @@
+from typing import Any
+
+import requests
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import DropdownInput, SecretStrInput, StrInput
+from lfx.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"]

lfx/components/Notion/update_page_property.py

@@ -0,0 +1,114 @@
+import json
+from typing import Any
+
+import requests
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import MultilineInput, SecretStrInput, StrInput
+from lfx.log.logger import logger
+from lfx.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)