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

langflow/components/FAISS/faiss.py

@@ -1,111 +0,0 @@
-from pathlib import Path
-
-from langchain_community.vectorstores import FAISS
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.io import BoolInput, HandleInput, IntInput, StrInput
-from langflow.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 []

langflow/components/Notion/__init__.py

@@ -1,19 +0,0 @@
-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",
-]

langflow/components/Notion/add_content_to_page.py

@@ -1,269 +0,0 @@
-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 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
-
-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

langflow/components/Notion/create_page.py

@@ -1,94 +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.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)

langflow/components/Notion/list_database_properties.py

@@ -1,68 +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 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}"

langflow/components/Notion/list_pages.py

@@ -1,122 +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 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}"