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

lfx/components/FAISS/faiss.py

@@ -0,0 +1,111 @@
+from pathlib import Path
+
+from langchain_community.vectorstores import FAISS
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import BoolInput, HandleInput, IntInput, StrInput
+from lfx.schema.data import Data
+
+
+class FaissVectorStoreComponent(LCVectorStoreComponent):
+    """FAISS Vector Store with search capabilities."""
+
+    display_name: str = "FAISS"
+    description: str = "FAISS Vector Store with search capabilities"
+    name = "FAISS"
+    icon = "FAISS"
+
+    inputs = [
+        StrInput(
+            name="index_name",
+            display_name="Index Name",
+            value="langflow_index",
+        ),
+        StrInput(
+            name="persist_directory",
+            display_name="Persist Directory",
+            info="Path to save the FAISS index. It will be relative to where Langflow is running.",
+        ),
+        *LCVectorStoreComponent.inputs,
+        BoolInput(
+            name="allow_dangerous_deserialization",
+            display_name="Allow Dangerous Deserialization",
+            info="Set to True to allow loading pickle files from untrusted sources. "
+            "Only enable this if you trust the source of the data.",
+            advanced=True,
+            value=True,
+        ),
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            advanced=True,
+            value=4,
+        ),
+    ]
+
+    @staticmethod
+    def resolve_path(path: str) -> str:
+        """Resolve the path relative to the Langflow root.
+
+        Args:
+            path: The path to resolve
+        Returns:
+            str: The resolved path as a string
+        """
+        return str(Path(path).resolve())
+
+    def get_persist_directory(self) -> Path:
+        """Returns the resolved persist directory path or the current directory if not set."""
+        if self.persist_directory:
+            return Path(self.resolve_path(self.persist_directory))
+        return Path()
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> FAISS:
+        """Builds the FAISS object."""
+        path = self.get_persist_directory()
+        path.mkdir(parents=True, exist_ok=True)
+
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        faiss = FAISS.from_documents(documents=documents, embedding=self.embedding)
+        faiss.save_local(str(path), self.index_name)
+        return faiss
+
+    def search_documents(self) -> list[Data]:
+        """Search for documents in the FAISS vector store."""
+        path = self.get_persist_directory()
+        index_path = path / f"{self.index_name}.faiss"
+
+        if not index_path.exists():
+            vector_store = self.build_vector_store()
+        else:
+            vector_store = FAISS.load_local(
+                folder_path=str(path),
+                embeddings=self.embedding,
+                index_name=self.index_name,
+                allow_dangerous_deserialization=self.allow_dangerous_deserialization,
+            )
+
+        if not vector_store:
+            msg = "Failed to load the FAISS index."
+            raise ValueError(msg)
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+            return docs_to_data(docs)
+        return []

lfx/components/Notion/__init__.py

@@ -0,0 +1,19 @@
+from .add_content_to_page import AddContentToPage
+from .create_page import NotionPageCreator
+from .list_database_properties import NotionDatabaseProperties
+from .list_pages import NotionListPages
+from .list_users import NotionUserList
+from .page_content_viewer import NotionPageContent
+from .search import NotionSearch
+from .update_page_property import NotionPageUpdate
+
+__all__ = [
+    "AddContentToPage",
+    "NotionDatabaseProperties",
+    "NotionListPages",
+    "NotionPageContent",
+    "NotionPageCreator",
+    "NotionPageUpdate",
+    "NotionSearch",
+    "NotionUserList",
+]

lfx/components/Notion/add_content_to_page.py

@@ -0,0 +1,269 @@
+import json
+from typing import Any
+
+import requests
+from bs4 import BeautifulSoup
+from langchain.tools import StructuredTool
+from markdown import markdown
+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
+
+MIN_ROWS_IN_TABLE = 3
+
+
+class AddContentToPage(LCToolComponent):
+    display_name: str = "Add Content to Page "
+    description: str = "Convert markdown text to Notion blocks and append them to a Notion page."
+    documentation: str = "https://developers.notion.com/reference/patch-block-children"
+    icon = "NotionDirectoryLoader"
+
+    inputs = [
+        MultilineInput(
+            name="markdown_text",
+            display_name="Markdown Text",
+            info="The markdown text to convert to Notion blocks.",
+        ),
+        StrInput(
+            name="block_id",
+            display_name="Page/Block ID",
+            info="The ID of the page/block to add the content.",
+        ),
+        SecretStrInput(
+            name="notion_secret",
+            display_name="Notion Secret",
+            info="The Notion integration token.",
+            required=True,
+        ),
+    ]
+
+    class AddContentToPageSchema(BaseModel):
+        markdown_text: str = Field(..., description="The markdown text to convert to Notion blocks.")
+        block_id: str = Field(..., description="The ID of the page/block to add the content.")
+
+    def run_model(self) -> Data:
+        result = self._add_content_to_page(self.markdown_text, self.block_id)
+        return Data(data=result, text=json.dumps(result))
+
+    def build_tool(self) -> Tool:
+        return StructuredTool.from_function(
+            name="add_content_to_notion_page",
+            description="Convert markdown text to Notion blocks and append them to a Notion page.",
+            func=self._add_content_to_page,
+            args_schema=self.AddContentToPageSchema,
+        )
+
+    def _add_content_to_page(self, markdown_text: str, block_id: str) -> dict[str, Any] | str:
+        try:
+            html_text = markdown(markdown_text)
+            soup = BeautifulSoup(html_text, "html.parser")
+            blocks = self.process_node(soup)
+
+            url = f"https://api.notion.com/v1/blocks/{block_id}/children"
+            headers = {
+                "Authorization": f"Bearer {self.notion_secret}",
+                "Content-Type": "application/json",
+                "Notion-Version": "2022-06-28",
+            }
+
+            data = {
+                "children": blocks,
+            }
+
+            response = requests.patch(url, headers=headers, json=data, timeout=10)
+            response.raise_for_status()
+
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            error_message = f"Error: Failed to add content to Notion page. {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 adding content to Notion page", exc_info=True)
+            return f"Error: An unexpected error occurred while adding content to Notion page. {e}"
+
+    def process_node(self, node):
+        blocks = []
+        if isinstance(node, str):
+            text = node.strip()
+            if text:
+                if text.startswith("#"):
+                    heading_level = text.count("#", 0, 6)
+                    heading_text = text[heading_level:].strip()
+                    if heading_level in range(3):
+                        blocks.append(self.create_block(f"heading_{heading_level + 1}", heading_text))
+                else:
+                    blocks.append(self.create_block("paragraph", text))
+        elif node.name == "h1":
+            blocks.append(self.create_block("heading_1", node.get_text(strip=True)))
+        elif node.name == "h2":
+            blocks.append(self.create_block("heading_2", node.get_text(strip=True)))
+        elif node.name == "h3":
+            blocks.append(self.create_block("heading_3", node.get_text(strip=True)))
+        elif node.name == "p":
+            code_node = node.find("code")
+            if code_node:
+                code_text = code_node.get_text()
+                language, code = self.extract_language_and_code(code_text)
+                blocks.append(self.create_block("code", code, language=language))
+            elif self.is_table(str(node)):
+                blocks.extend(self.process_table(node))
+            else:
+                blocks.append(self.create_block("paragraph", node.get_text(strip=True)))
+        elif node.name == "ul":
+            blocks.extend(self.process_list(node, "bulleted_list_item"))
+        elif node.name == "ol":
+            blocks.extend(self.process_list(node, "numbered_list_item"))
+        elif node.name == "blockquote":
+            blocks.append(self.create_block("quote", node.get_text(strip=True)))
+        elif node.name == "hr":
+            blocks.append(self.create_block("divider", ""))
+        elif node.name == "img":
+            blocks.append(self.create_block("image", "", image_url=node.get("src")))
+        elif node.name == "a":
+            blocks.append(self.create_block("bookmark", node.get_text(strip=True), link_url=node.get("href")))
+        elif node.name == "table":
+            blocks.extend(self.process_table(node))
+
+        for child in node.children:
+            if isinstance(child, str):
+                continue
+            blocks.extend(self.process_node(child))
+
+        return blocks
+
+    def extract_language_and_code(self, code_text):
+        lines = code_text.split("\n")
+        language = lines[0].strip()
+        code = "\n".join(lines[1:]).strip()
+        return language, code
+
+    def is_code_block(self, text):
+        return text.startswith("```")
+
+    def extract_code_block(self, text):
+        lines = text.split("\n")
+        language = lines[0].strip("`").strip()
+        code = "\n".join(lines[1:]).strip("`").strip()
+        return language, code
+
+    def is_table(self, text):
+        rows = text.split("\n")
+        if len(rows) < MIN_ROWS_IN_TABLE:
+            return False
+
+        has_separator = False
+        for i, row in enumerate(rows):
+            if "|" in row:
+                cells = [cell.strip() for cell in row.split("|")]
+                cells = [cell for cell in cells if cell]  # Remove empty cells
+                if i == 1 and all(set(cell) <= set("-|") for cell in cells):
+                    has_separator = True
+                elif not cells:
+                    return False
+
+        return has_separator
+
+    def process_list(self, node, list_type):
+        blocks = []
+        for item in node.find_all("li"):
+            item_text = item.get_text(strip=True)
+            checked = item_text.startswith("[x]")
+            is_checklist = item_text.startswith("[ ]") or checked
+
+            if is_checklist:
+                item_text = item_text.replace("[x]", "").replace("[ ]", "").strip()
+                blocks.append(self.create_block("to_do", item_text, checked=checked))
+            else:
+                blocks.append(self.create_block(list_type, item_text))
+        return blocks
+
+    def process_table(self, node):
+        blocks = []
+        header_row = node.find("thead").find("tr") if node.find("thead") else None
+        body_rows = node.find("tbody").find_all("tr") if node.find("tbody") else []
+
+        if header_row or body_rows:
+            table_width = max(
+                len(header_row.find_all(["th", "td"])) if header_row else 0,
+                *(len(row.find_all(["th", "td"])) for row in body_rows),
+            )
+
+            table_block = self.create_block("table", "", table_width=table_width, has_column_header=bool(header_row))
+            blocks.append(table_block)
+
+            if header_row:
+                header_cells = [cell.get_text(strip=True) for cell in header_row.find_all(["th", "td"])]
+                header_row_block = self.create_block("table_row", header_cells)
+                blocks.append(header_row_block)
+
+            for row in body_rows:
+                cells = [cell.get_text(strip=True) for cell in row.find_all(["th", "td"])]
+                row_block = self.create_block("table_row", cells)
+                blocks.append(row_block)
+
+        return blocks
+
+    def create_block(self, block_type: str, content: str, **kwargs) -> dict[str, Any]:
+        block: dict[str, Any] = {
+            "object": "block",
+            "type": block_type,
+            block_type: {},
+        }
+
+        if block_type in {
+            "paragraph",
+            "heading_1",
+            "heading_2",
+            "heading_3",
+            "bulleted_list_item",
+            "numbered_list_item",
+            "quote",
+        }:
+            block[block_type]["rich_text"] = [
+                {
+                    "type": "text",
+                    "text": {
+                        "content": content,
+                    },
+                }
+            ]
+        elif block_type == "to_do":
+            block[block_type]["rich_text"] = [
+                {
+                    "type": "text",
+                    "text": {
+                        "content": content,
+                    },
+                }
+            ]
+            block[block_type]["checked"] = kwargs.get("checked", False)
+        elif block_type == "code":
+            block[block_type]["rich_text"] = [
+                {
+                    "type": "text",
+                    "text": {
+                        "content": content,
+                    },
+                }
+            ]
+            block[block_type]["language"] = kwargs.get("language", "plain text")
+        elif block_type == "image":
+            block[block_type] = {"type": "external", "external": {"url": kwargs.get("image_url", "")}}
+        elif block_type == "divider":
+            pass
+        elif block_type == "bookmark":
+            block[block_type]["url"] = kwargs.get("link_url", "")
+        elif block_type == "table":
+            block[block_type]["table_width"] = kwargs.get("table_width", 0)
+            block[block_type]["has_column_header"] = kwargs.get("has_column_header", False)
+            block[block_type]["has_row_header"] = kwargs.get("has_row_header", False)
+        elif block_type == "table_row":
+            block[block_type]["cells"] = [[{"type": "text", "text": {"content": cell}} for cell in content]]
+
+        return block

lfx/components/Notion/create_page.py

@@ -0,0 +1,94 @@
+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.schema.data import Data
+
+
+class NotionPageCreator(LCToolComponent):
+    display_name: str = "Create Page "
+    description: str = "A component for creating Notion pages."
+    documentation: str = "https://docs.langflow.org/integrations/notion/page-create"
+    icon = "NotionDirectoryLoader"
+
+    inputs = [
+        StrInput(
+            name="database_id",
+            display_name="Database ID",
+            info="The ID of the Notion database.",
+        ),
+        SecretStrInput(
+            name="notion_secret",
+            display_name="Notion Secret",
+            info="The Notion integration token.",
+            required=True,
+        ),
+        MultilineInput(
+            name="properties_json",
+            display_name="Properties (JSON)",
+            info="The properties of the new page as a JSON string.",
+        ),
+    ]
+
+    class NotionPageCreatorSchema(BaseModel):
+        database_id: str = Field(..., description="The ID of the Notion database.")
+        properties_json: str = Field(..., description="The properties of the new page as a JSON string.")
+
+    def run_model(self) -> Data:
+        result = self._create_notion_page(self.database_id, self.properties_json)
+        if isinstance(result, str):
+            # An error occurred, return it as text
+            return Data(text=result)
+        # Success, return the created page data
+        output = "Created 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="create_notion_page",
+            description="Create a new page in a Notion database. "
+            "IMPORTANT: Use the tool to check the Database properties for more details before using this tool.",
+            func=self._create_notion_page,
+            args_schema=self.NotionPageCreatorSchema,
+        )
+
+    def _create_notion_page(self, database_id: str, properties_json: str) -> dict[str, Any] | str:
+        if not database_id or not properties_json:
+            return "Invalid input. Please provide 'database_id' and 'properties_json'."
+
+        try:
+            properties = json.loads(properties_json)
+        except json.JSONDecodeError as e:
+            return f"Invalid properties format. Please provide a valid JSON string. Error: {e}"
+
+        headers = {
+            "Authorization": f"Bearer {self.notion_secret}",
+            "Content-Type": "application/json",
+            "Notion-Version": "2022-06-28",
+        }
+
+        data = {
+            "parent": {"database_id": database_id},
+            "properties": properties,
+        }
+
+        try:
+            response = requests.post("https://api.notion.com/v1/pages", headers=headers, json=data, timeout=10)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            error_message = f"Failed to create Notion page. Error: {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
+
+    def __call__(self, *args, **kwargs):
+        return self._create_notion_page(*args, **kwargs)

lfx/components/Notion/list_database_properties.py

@@ -0,0 +1,68 @@
+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 NotionDatabaseProperties(LCToolComponent):
+    display_name: str = "List Database Properties "
+    description: str = "Retrieve properties of a Notion database."
+    documentation: str = "https://docs.langflow.org/integrations/notion/list-database-properties"
+    icon = "NotionDirectoryLoader"
+
+    inputs = [
+        StrInput(
+            name="database_id",
+            display_name="Database ID",
+            info="The ID of the Notion database.",
+        ),
+        SecretStrInput(
+            name="notion_secret",
+            display_name="Notion Secret",
+            info="The Notion integration token.",
+            required=True,
+        ),
+    ]
+
+    class NotionDatabasePropertiesSchema(BaseModel):
+        database_id: str = Field(..., description="The ID of the Notion database.")
+
+    def run_model(self) -> Data:
+        result = self._fetch_database_properties(self.database_id)
+        if isinstance(result, str):
+            # An error occurred, return it as text
+            return Data(text=result)
+        # Success, return the properties
+        return Data(text=str(result), data=result)
+
+    def build_tool(self) -> Tool:
+        return StructuredTool.from_function(
+            name="notion_database_properties",
+            description="Retrieve properties of a Notion database. Input should include the database ID.",
+            func=self._fetch_database_properties,
+            args_schema=self.NotionDatabasePropertiesSchema,
+        )
+
+    def _fetch_database_properties(self, database_id: str) -> dict | str:
+        url = f"https://api.notion.com/v1/databases/{database_id}"
+        headers = {
+            "Authorization": f"Bearer {self.notion_secret}",
+            "Notion-Version": "2022-06-28",  # Use the latest supported version
+        }
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("properties", {})
+        except requests.exceptions.RequestException as e:
+            return f"Error fetching Notion database properties: {e}"
+        except ValueError as e:
+            return f"Error parsing Notion API response: {e}"
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error fetching Notion database properties", exc_info=True)
+            return f"An unexpected error occurred: {e}"

lfx/components/Notion/list_pages.py

@@ -0,0 +1,122 @@
+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 NotionListPages(LCToolComponent):
+    display_name: str = "List Pages "
+    description: str = (
+        "Query a Notion database with filtering and sorting. "
+        "The input should be a JSON string containing the 'filter' and 'sorts' objects. "
+        "Example input:\n"
+        '{"filter": {"property": "Status", "select": {"equals": "Done"}}, '
+        '"sorts": [{"timestamp": "created_time", "direction": "descending"}]}'
+    )
+    documentation: str = "https://docs.langflow.org/integrations/notion/list-pages"
+    icon = "NotionDirectoryLoader"
+
+    inputs = [
+        SecretStrInput(
+            name="notion_secret",
+            display_name="Notion Secret",
+            info="The Notion integration token.",
+            required=True,
+        ),
+        StrInput(
+            name="database_id",
+            display_name="Database ID",
+            info="The ID of the Notion database to query.",
+        ),
+        MultilineInput(
+            name="query_json",
+            display_name="Database query (JSON)",
+            info="A JSON string containing the filters and sorts that will be used for querying the database. "
+            "Leave empty for no filters or sorts.",
+        ),
+    ]
+
+    class NotionListPagesSchema(BaseModel):
+        database_id: str = Field(..., description="The ID of the Notion database to query.")
+        query_json: str | None = Field(
+            default="",
+            description="A JSON string containing the filters and sorts for querying the database. "
+            "Leave empty for no filters or sorts.",
+        )
+
+    def run_model(self) -> list[Data]:
+        result = self._query_notion_database(self.database_id, self.query_json)
+
+        if isinstance(result, str):
+            # An error occurred, return it as a single record
+            return [Data(text=result)]
+
+        records = []
+        combined_text = f"Pages found: {len(result)}\n\n"
+
+        for page in result:
+            page_data = {
+                "id": page["id"],
+                "url": page["url"],
+                "created_time": page["created_time"],
+                "last_edited_time": page["last_edited_time"],
+                "properties": page["properties"],
+            }
+
+            text = (
+                f"id: {page['id']}\n"
+                f"url: {page['url']}\n"
+                f"created_time: {page['created_time']}\n"
+                f"last_edited_time: {page['last_edited_time']}\n"
+                f"properties: {json.dumps(page['properties'], indent=2)}\n\n"
+            )
+
+            combined_text += text
+            records.append(Data(text=text, **page_data))
+
+        self.status = records
+        return records
+
+    def build_tool(self) -> Tool:
+        return StructuredTool.from_function(
+            name="notion_list_pages",
+            description=self.description,
+            func=self._query_notion_database,
+            args_schema=self.NotionListPagesSchema,
+        )
+
+    def _query_notion_database(self, database_id: str, query_json: str | None = None) -> list[dict[str, Any]] | str:
+        url = f"https://api.notion.com/v1/databases/{database_id}/query"
+        headers = {
+            "Authorization": f"Bearer {self.notion_secret}",
+            "Content-Type": "application/json",
+            "Notion-Version": "2022-06-28",
+        }
+
+        query_payload = {}
+        if query_json and query_json.strip():
+            try:
+                query_payload = json.loads(query_json)
+            except json.JSONDecodeError as e:
+                return f"Invalid JSON format for query: {e}"
+
+        try:
+            response = requests.post(url, headers=headers, json=query_payload, timeout=10)
+            response.raise_for_status()
+            results = response.json()
+            return results["results"]
+        except requests.exceptions.RequestException as e:
+            return f"Error querying Notion database: {e}"
+        except KeyError:
+            return "Unexpected response format from Notion API"
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error querying Notion database", exc_info=True)
+            return f"An unexpected error occurred: {e}"